diff --git a/audio/2.0/config/audio_policy_configuration.xsd b/audio/2.0/config/audio_policy_configuration.xsd
new file mode 100644
index 0000000..48b9a9b
--- /dev/null
+++ b/audio/2.0/config/audio_policy_configuration.xsd
@@ -0,0 +1,496 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (C) 2017 The Android Open Source Project
+
+         Licensed under the Apache License, Version 2.0 (the "License");
+         you may not use this file except in compliance with the License.
+         You may obtain a copy of the License at
+
+                    http://www.apache.org/licenses/LICENSE-2.0
+
+         Unless required by applicable law or agreed to in writing, software
+         distributed under the License is distributed on an "AS IS" BASIS,
+         WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+         See the License for the specific language governing permissions and
+         limitations under the License.
+-->
+<!-- TODO: define a targetNamespace. Note that it will break retrocompatibility -->
+<xs:schema version="2.0"
+           elementFormDefault="qualified"
+           attributeFormDefault="unqualified"
+           xmlns:xs="http://www.w3.org/2001/XMLSchema">
+    <!-- List the config versions supported by audio policy. -->
+    <xs:simpleType name="version">
+        <xs:restriction base="xs:decimal">
+            <xs:enumeration value="1.0"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <xs:simpleType name="halVersion">
+        <xs:annotation>
+            <xs:documentation xml:lang="en">
+                Version of the interface the hal implements.
+            </xs:documentation>
+        </xs:annotation>
+        <xs:restriction base="xs:decimal">
+            <!-- List of HAL versions supported by the framework. -->
+            <xs:enumeration value="2.0"/>
+            <xs:enumeration value="3.0"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <xs:element name="audioPolicyConfiguration">
+        <xs:complexType>
+            <xs:sequence>
+                <xs:element name="globalConfiguration" type="globalConfiguration"/>
+                <xs:element name="modules" type="modules" maxOccurs="unbounded"/>
+                <xs:element name="volumes" type="volumes" maxOccurs="unbounded"/>
+            </xs:sequence>
+            <xs:attribute name="version" type="version"/>
+        </xs:complexType>
+        <xs:key name="moduleNameKey">
+            <xs:selector xpath="modules/module"/>
+            <xs:field xpath="@name"/>
+        </xs:key>
+        <xs:key name="devicePortNameGlobalKey">
+            <xs:selector xpath="modules/module/devicePorts/devicePort"/>
+            <xs:field xpath="@tagName"/>
+        </xs:key>
+        <xs:unique name="volumeTargetUniqueness">
+            <xs:selector xpath="volumes/volume"/>
+            <xs:field xpath="@stream"/>
+            <xs:field xpath="@deviceCategory"/>
+        </xs:unique>
+        <xs:key name="volumeCurveNameKey">
+            <xs:selector xpath="volumes/reference"/>
+            <xs:field xpath="@name"/>
+        </xs:key>
+        <xs:keyref name="volumeCurveRef" refer="volumeCurveNameKey">
+            <xs:selector xpath="volumes/volume"/>
+            <xs:field xpath="@ref"/>
+        </xs:keyref>
+    </xs:element>
+    <xs:complexType name="globalConfiguration">
+        <xs:attribute name="speaker_drc_enabled" type="xs:boolean" use="required"/>
+    </xs:complexType>
+    <!-- Enum values of IDevicesFactory::Device
+         TODO: generate from hidl to avoid manual sync. -->
+    <xs:simpleType name="halName">
+        <xs:restriction base="xs:string">
+            <xs:enumeration value="primary"/>
+            <xs:enumeration value="a2dp"/>
+            <xs:enumeration value="usb"/>
+            <xs:enumeration value="r_submix"/>
+            <xs:enumeration value="codec_offload"/>
+            <xs:enumeration value="stub"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <xs:complexType name="modules">
+        <xs:annotation>
+            <xs:documentation xml:lang="en">
+                There should be one section per audio HW module present on the platform.
+                Each <module/> contains two mandatory tags: “halVersion” and “name”.
+                The module "name" is the same as in previous .conf file.
+                Each module must contain the following sections:
+                 - <devicePorts/>: a list of device descriptors for all
+                   input and output devices accessible via this module.
+                   This contains both permanently attached devices and removable devices.
+                 - <mixPorts/>: listing all output and input streams exposed by the audio HAL
+                 - <routes/>: list of possible connections between input
+                   and output devices or between stream and devices.
+                   A <route/> is defined by a set of 3 attributes:
+                        -"type": mux|mix means all sources are mutual exclusive (mux) or can be mixed (mix)
+                        -"sink": the sink involved in this route
+                        -"sources": all the sources than can be connected to the sink via this route
+                 - <attachedDevices/>: permanently attached devices.
+                   The attachedDevices section is a list of devices names.
+                   Their names correspond to device names defined in "devicePorts" section.
+                 - <defaultOutputDevice/> is the device to be used when no policy rule applies
+            </xs:documentation>
+        </xs:annotation>
+        <xs:sequence>
+            <xs:element name="module" maxOccurs="unbounded">
+                <xs:complexType>
+                    <xs:sequence>
+                        <xs:element name="attachedDevices" type="attachedDevices" minOccurs="0">
+                            <xs:unique name="attachedDevicesUniqueness">
+                                <xs:selector xpath="item"/>
+                                <xs:field xpath="."/>
+                            </xs:unique>
+                        </xs:element>
+                        <xs:element name="defaultOutputDevice" type="xs:token" minOccurs="0"/>
+                        <xs:element name="mixPorts" type="mixPorts" minOccurs="0"/>
+                        <xs:element name="devicePorts" type="devicePorts" minOccurs="0"/>
+                        <xs:element name="routes" type="routes" minOccurs="0"/>
+                    </xs:sequence>
+                    <xs:attribute name="name" type="halName" use="required"/>
+                    <xs:attribute name="halVersion" type="halVersion" use="required"/>
+                </xs:complexType>
+                <xs:unique name="mixPortNameUniqueness">
+                    <xs:selector xpath="mixPorts/mixPort"/>
+                    <xs:field xpath="@name"/>
+                </xs:unique>
+                <!-- Although this key constraint is redundant with devicePortNameGlobalKey,
+                     the set is used to constraint defaultOutputDevice and attachedDevice
+                     to reference a devicePort of the same module. -->
+                <xs:key name="devicePortNameKey">
+                    <xs:selector xpath="devicePorts/devicePort"/>
+                    <xs:field xpath="@tagName"/>
+                </xs:key>
+                <xs:keyref name="defaultOutputDeviceRef" refer="devicePortNameKey">
+                    <xs:selector xpath="defaultOutputDevice"/>
+                    <xs:field xpath="."/>
+                </xs:keyref>
+                <xs:keyref name="attachedDeviceRef" refer="devicePortNameKey">
+                    <xs:selector xpath="attachedDevices/item"/>
+                    <xs:field xpath="."/>
+                </xs:keyref>
+                <!-- The following 3 constraints try to make sure each sink port
+                     is reference in one an only one route. -->
+                <xs:key name="routeSinkKey">
+                    <!-- predicate [@type='sink'] does not work in xsd 1.0 -->
+                    <xs:selector xpath="devicePorts/devicePort|mixPorts/mixPort"/>
+                    <xs:field xpath="@tagName|@name"/>
+                </xs:key>
+                <xs:keyref name="routeSinkRef" refer="routeSinkKey">
+                    <xs:selector xpath="routes/route"/>
+                    <xs:field xpath="@sink"/>
+                </xs:keyref>
+                <xs:unique name="routeUniqueness">
+                    <xs:selector xpath="routes/route"/>
+                    <xs:field xpath="@sink"/>
+                </xs:unique>
+            </xs:element>
+        </xs:sequence>
+    </xs:complexType>
+    <xs:complexType name="attachedDevices">
+        <xs:sequence>
+            <xs:element name="item" type="xs:token" minOccurs="0" maxOccurs="unbounded"/>
+        </xs:sequence>
+    </xs:complexType>
+    <!-- TODO: separate values by space for better xsd validations. -->
+    <xs:simpleType name="audioInOutFlags">
+        <xs:annotation>
+            <xs:documentation xml:lang="en">
+                "|" separated list of audio_output_flags_t or audio_input_flags_t.
+            </xs:documentation>
+        </xs:annotation>
+        <xs:restriction base="xs:string">
+            <xs:pattern value="|[_A-Z]+(\|[_A-Z]+)*"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <xs:simpleType name="role">
+        <xs:restriction base="xs:string">
+            <xs:enumeration value="sink"/>
+            <xs:enumeration value="source"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <xs:complexType name="mixPorts">
+        <xs:sequence>
+            <xs:element name="mixPort" minOccurs="0" maxOccurs="unbounded">
+                <xs:complexType>
+                    <xs:sequence>
+                        <xs:element name="profile" type="profile" minOccurs="0" maxOccurs="unbounded"/>
+                    </xs:sequence>
+                    <xs:attribute name="name" type="xs:token" use="required"/>
+                    <xs:attribute name="role" type="role" use="required"/>
+                    <xs:attribute name="flags" type="audioInOutFlags"/>
+                </xs:complexType>
+                <xs:unique name="mixPortProfileUniqueness">
+                    <xs:selector xpath="profile"/>
+                    <xs:field xpath="format"/>
+                    <xs:field xpath="samplingRate"/>
+                    <xs:field xpath="channelMasks"/>
+                </xs:unique>
+            </xs:element>
+        </xs:sequence>
+    </xs:complexType>
+    <!-- Enum values of audio_device_t in audio.h
+         TODO: generate from hidl to avoid manual sync.
+         TODO: separate source and sink in the xml for better xsd validations. -->
+    <xs:simpleType name="audioDevice">
+        <xs:restriction base="xs:string">
+            <xs:enumeration value="AUDIO_DEVICE_NONE"/>
+
+            <xs:enumeration value="AUDIO_DEVICE_OUT_EARPIECE"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_SPEAKER"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_SPEAKER_SAFE"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_WIRED_HEADSET"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_WIRED_HEADPHONE"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_BLUETOOTH_SCO"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_ALL_SCO"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_BLUETOOTH_A2DP"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_ALL_A2DP"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_AUX_DIGITAL"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_HDMI"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_USB_ACCESSORY"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_USB_DEVICE"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_ALL_USB"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_REMOTE_SUBMIX"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_TELEPHONY_TX"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_LINE"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_HDMI_ARC"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_SPDIF"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_FM"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_AUX_LINE"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_IP"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_BUS"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_PROXY"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_USB_HEADSET"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_DEFAULT"/>
+            <xs:enumeration value="AUDIO_DEVICE_OUT_STUB"/>
+
+            <!-- Due to the xml format, IN types can not be a separated from OUT types -->
+            <xs:enumeration value="AUDIO_DEVICE_IN_COMMUNICATION"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_AMBIENT"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_BUILTIN_MIC"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_ALL_SCO"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_WIRED_HEADSET"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_AUX_DIGITAL"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_HDMI"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_TELEPHONY_RX"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_VOICE_CALL"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_BACK_MIC"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_REMOTE_SUBMIX"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_USB_ACCESSORY"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_USB_DEVICE"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_ALL_USB"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_FM_TUNER"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_TV_TUNER"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_LINE"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_SPDIF"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_BLUETOOTH_A2DP"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_LOOPBACK"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_IP"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_BUS"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_PROXY"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_USB_HEADSET"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_DEFAULT"/>
+            <xs:enumeration value="AUDIO_DEVICE_IN_STUB"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <!-- Enum values of audio_format_t in audio.h
+         TODO: generate from hidl to avoid manual sync. -->
+    <xs:simpleType name="audioFormat">
+        <xs:restriction base="xs:string">
+            <xs:enumeration value="AUDIO_FORMAT_PCM_16_BIT" />
+            <xs:enumeration value="AUDIO_FORMAT_PCM_8_BIT"/>
+            <xs:enumeration value="AUDIO_FORMAT_PCM_32_BIT"/>
+            <xs:enumeration value="AUDIO_FORMAT_PCM_8_24_BIT"/>
+            <xs:enumeration value="AUDIO_FORMAT_PCM_FLOAT"/>
+            <xs:enumeration value="AUDIO_FORMAT_PCM_24_BIT_PACKED"/>
+            <xs:enumeration value="AUDIO_FORMAT_MP3"/>
+            <xs:enumeration value="AUDIO_FORMAT_AMR_NB"/>
+            <xs:enumeration value="AUDIO_FORMAT_AMR_WB"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_MAIN"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_LC"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_SSR"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_LTP"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_HE_V1"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_SCALABLE"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ERLC"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_LD"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_HE_V2"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ELD"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS_MAIN"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS_LC"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS_SSR"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS_LTP"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS_HE_V1"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS_SCALABLE"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS_ERLC"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS_LD"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS_HE_V2"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS_ELD"/>
+            <xs:enumeration value="AUDIO_FORMAT_VORBIS"/>
+            <xs:enumeration value="AUDIO_FORMAT_HE_AAC_V1"/>
+            <xs:enumeration value="AUDIO_FORMAT_HE_AAC_V2"/>
+            <xs:enumeration value="AUDIO_FORMAT_OPUS"/>
+            <xs:enumeration value="AUDIO_FORMAT_AC3"/>
+            <xs:enumeration value="AUDIO_FORMAT_E_AC3"/>
+            <xs:enumeration value="AUDIO_FORMAT_DTS"/>
+            <xs:enumeration value="AUDIO_FORMAT_DTS_HD"/>
+            <xs:enumeration value="AUDIO_FORMAT_IEC61937"/>
+            <xs:enumeration value="AUDIO_FORMAT_DOLBY_TRUEHD"/>
+            <xs:enumeration value="AUDIO_FORMAT_EVRC"/>
+            <xs:enumeration value="AUDIO_FORMAT_EVRCB"/>
+            <xs:enumeration value="AUDIO_FORMAT_EVRCWB"/>
+            <xs:enumeration value="AUDIO_FORMAT_EVRCNW"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADIF"/>
+            <xs:enumeration value="AUDIO_FORMAT_WMA"/>
+            <xs:enumeration value="AUDIO_FORMAT_WMA_PRO"/>
+            <xs:enumeration value="AUDIO_FORMAT_AMR_WB_PLUS"/>
+            <xs:enumeration value="AUDIO_FORMAT_MP2"/>
+            <xs:enumeration value="AUDIO_FORMAT_QCELP"/>
+            <xs:enumeration value="AUDIO_FORMAT_DSD"/>
+            <xs:enumeration value="AUDIO_FORMAT_FLAC"/>
+            <xs:enumeration value="AUDIO_FORMAT_ALAC"/>
+            <xs:enumeration value="AUDIO_FORMAT_APE"/>
+            <xs:enumeration value="AUDIO_FORMAT_AAC_ADTS"/>
+            <xs:enumeration value="AUDIO_FORMAT_SBC"/>
+            <xs:enumeration value="AUDIO_FORMAT_APTX"/>
+            <xs:enumeration value="AUDIO_FORMAT_APTX_HD"/>
+            <xs:enumeration value="AUDIO_FORMAT_AC4"/>
+            <xs:enumeration value="AUDIO_FORMAT_LDAC"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <!-- TODO: Change to a space separated list to xsd enforce correctness. -->
+    <xs:simpleType name="samplingRates">
+        <xs:restriction base="xs:string">
+            <xs:pattern value="[0-9]+(,[0-9]+)*"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <!-- TODO: Change to a space separated list to xsd enforce correctness. -->
+    <xs:simpleType name="channelMask">
+        <xs:annotation>
+            <xs:documentation xml:lang="en">
+                Comma (",") separated list of channel flags
+                from audio_channel_mask_t.
+            </xs:documentation>
+        </xs:annotation>
+        <xs:restriction base="xs:string">
+            <xs:pattern value="[_A-Z][_A-Z0-9]*(,[_A-Z][_A-Z0-9]*)*"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <xs:complexType name="profile">
+        <xs:attribute name="name" type="xs:token" use="required"/>
+        <xs:attribute name="format" type="audioFormat" use="required"/>
+        <xs:attribute name="samplingRates" type="samplingRates" use="required"/>
+        <xs:attribute name="channelMasks" type="channelMask" use="required"/>
+    </xs:complexType>
+    <xs:complexType name="devicePorts">
+        <xs:sequence>
+            <xs:element name="devicePort" minOccurs="0" maxOccurs="unbounded">
+                <xs:complexType>
+                    <xs:sequence>
+                        <xs:element name="profile" type="profile" minOccurs="0" maxOccurs="unbounded"/>
+                    </xs:sequence>
+                    <xs:attribute name="tagName" type="xs:token" use="required"/>
+                    <xs:attribute name="type" type="audioDevice" use="required"/>
+                    <xs:attribute name="role" type="role" use="required"/>
+                </xs:complexType>
+                <xs:unique name="devicePortProfileUniqueness">
+                    <xs:selector xpath="profile"/>
+                    <xs:field xpath="format"/>
+                    <xs:field xpath="samplingRate"/>
+                    <xs:field xpath="channelMasks"/>
+                </xs:unique>
+            </xs:element>
+        </xs:sequence>
+    </xs:complexType>
+    <xs:simpleType name="mixType">
+        <xs:restriction base="xs:string">
+            <xs:enumeration value="mix"/>
+            <xs:enumeration value="mux"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <xs:complexType name="routes">
+        <xs:sequence>
+            <xs:element name="route" minOccurs="0" maxOccurs="unbounded">
+                <xs:annotation>
+                    <xs:documentation xml:lang="en">
+                        List all available sources for a given sink.
+                    </xs:documentation>
+                </xs:annotation>
+                <xs:complexType>
+                    <xs:attribute name="type" type="mixType" use="required"/>
+                    <xs:attribute name="sink" type="xs:string" use="required"/>
+                    <xs:attribute name="sources" type="xs:string" use="required"/>
+                </xs:complexType>
+            </xs:element>
+        </xs:sequence>
+    </xs:complexType>
+    <xs:complexType name="volumes">
+        <xs:sequence>
+            <xs:element name="volume" type="volume" minOccurs="0" maxOccurs="unbounded"/>
+            <xs:element name="reference" type="reference" minOccurs="0" maxOccurs="unbounded">
+            </xs:element>
+        </xs:sequence>
+    </xs:complexType>
+    <!-- TODO: Always require a ref for better xsd validations.
+               Currently a volume could have no points nor ref
+               as it can not be forbidden by xsd 1.0.-->
+    <xs:simpleType name="volumePoint">
+        <xs:annotation>
+            <xs:documentation xml:lang="en">
+                Comma separated pair of number.
+                The fist one is the framework level (between 0 and 100).
+                The second one is the volume to send to the HAL.
+                The framework will interpolate volumes not specified.
+                Their MUST be at least 2 points specified.
+            </xs:documentation>
+        </xs:annotation>
+        <xs:restriction base="xs:string">
+            <xs:pattern value="([0-9]{1,2}|100),-?[0-9]+"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <!-- Enum values of audio_stream_type_t in audio-base.h
+         TODO: generate from hidl to avoid manual sync. -->
+    <xs:simpleType name="stream">
+        <xs:restriction base="xs:string">
+            <xs:enumeration value="AUDIO_STREAM_VOICE_CALL"/>
+            <xs:enumeration value="AUDIO_STREAM_SYSTEM"/>
+            <xs:enumeration value="AUDIO_STREAM_RING"/>
+            <xs:enumeration value="AUDIO_STREAM_MUSIC"/>
+            <xs:enumeration value="AUDIO_STREAM_ALARM"/>
+            <xs:enumeration value="AUDIO_STREAM_NOTIFICATION"/>
+            <xs:enumeration value="AUDIO_STREAM_BLUETOOTH_SCO"/>
+            <xs:enumeration value="AUDIO_STREAM_ENFORCED_AUDIBLE"/>
+            <xs:enumeration value="AUDIO_STREAM_DTMF"/>
+            <xs:enumeration value="AUDIO_STREAM_TTS"/>
+            <xs:enumeration value="AUDIO_STREAM_ACCESSIBILITY"/>
+            <xs:enumeration value="AUDIO_STREAM_REROUTING"/>
+            <xs:enumeration value="AUDIO_STREAM_PATCH"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <!-- Enum values of device_category from Volume.h.
+         TODO: generate from hidl to avoid manual sync. -->
+    <xs:simpleType name="deviceCategory">
+        <xs:restriction base="xs:string">
+            <xs:enumeration value="DEVICE_CATEGORY_HEADSET"/>
+            <xs:enumeration value="DEVICE_CATEGORY_SPEAKER"/>
+            <xs:enumeration value="DEVICE_CATEGORY_EARPIECE"/>
+            <xs:enumeration value="DEVICE_CATEGORY_EXT_MEDIA"/>
+        </xs:restriction>
+    </xs:simpleType>
+    <xs:complexType name="volume">
+        <xs:annotation>
+            <xs:documentation xml:lang="en">
+                Volume section defines a volume curve for a given use case and device category.
+                It contains a list of points of this curve expressing the attenuation in Millibels
+                for a given volume index from 0 to 100.
+                <volume stream="AUDIO_STREAM_MUSIC" deviceCategory="DEVICE_CATEGORY_SPEAKER">
+                    <point>0,-9600</point>
+                    <point>100,0</point>
+                </volume>
+
+                It may also reference a reference/@name to avoid duplicating curves.
+                <volume stream="AUDIO_STREAM_MUSIC" deviceCategory="DEVICE_CATEGORY_SPEAKER"
+                        ref="DEFAULT_MEDIA_VOLUME_CURVE"/>
+                <reference name="DEFAULT_MEDIA_VOLUME_CURVE">
+                    <point>0,-9600</point>
+                    <point>100,0</point>
+                </reference>
+            </xs:documentation>
+        </xs:annotation>
+        <xs:sequence>
+            <xs:element name="point" type="volumePoint" minOccurs="0" maxOccurs="unbounded"/>
+        </xs:sequence>
+        <xs:attribute name="stream" type="stream"/>
+        <xs:attribute name="deviceCategory" type="deviceCategory"/>
+        <xs:attribute name="ref" type="xs:token" use="optional"/>
+    </xs:complexType>
+    <xs:complexType name="reference">
+        <xs:sequence>
+            <xs:element name="point" type="volumePoint" minOccurs="2" maxOccurs="unbounded"/>
+        </xs:sequence>
+        <xs:attribute name="name" type="xs:token" use="required"/>
+    </xs:complexType>
+</xs:schema>
diff --git a/audio/2.0/default/Device.cpp b/audio/2.0/default/Device.cpp
index 280d320..3727966 100644
--- a/audio/2.0/default/Device.cpp
+++ b/audio/2.0/default/Device.cpp
@@ -17,11 +17,9 @@
 #define LOG_TAG "DeviceHAL"
 //#define LOG_NDEBUG 0
 
+#include <algorithm>
 #include <memory.h>
 #include <string.h>
-#include <algorithm>
-#include <mutex>
-#include <vector>
 
 #include <android/log.h>
 
@@ -38,57 +36,8 @@
 namespace V2_0 {
 namespace implementation {
 
-namespace {
-
-class Diagnostics {
-   public:
-    static Diagnostics& getInstance() {
-        std::lock_guard<std::mutex> _(mLock);
-        if (mInstance == nullptr) {
-            mInstance = new Diagnostics;
-        }
-        return *mInstance;
-    }
-
-    void registerDevice(Device* dev) {
-        std::lock_guard<std::mutex> _(mLock);
-        mDevices.push_back(wp<Device>(dev));
-    }
-
-    void checkForErasedHalCblk(const Device* dev) {
-        if (dev->version() != 0) return;  // all OK
-
-        std::ostringstream ss;
-        ss << "Zero HAL CB for " << dev->type() << ":" << std::hex
-           << dev->device() << "; Others: ";
-        {
-            std::lock_guard<std::mutex> _(mLock);
-            for (auto wp : mDevices) {
-                sp<Device> other{wp.promote()};
-                if (other.get() == nullptr || other.get() == dev) continue;
-                ss << other->type() << ":" << other->version() << ":"
-                   << std::hex << other->device() << "; ";
-            }
-        }
-        ALOGE("%s", ss.str().c_str());
-    }
-
-   private:
-    Diagnostics() {}
-
-    static std::mutex mLock;
-    static Diagnostics* mInstance;
-    std::vector<wp<Device>> mDevices;
-};
-
-std::mutex Diagnostics::mLock;
-Diagnostics* Diagnostics::mInstance{nullptr};
-
-}  // namespace
-
-Device::Device(audio_hw_device_t* device, const char* type)
-    : mDevice{device}, mType{type} {
-    Diagnostics::getInstance().registerDevice(this);
+Device::Device(audio_hw_device_t* device)
+        : mDevice(device) {
 }
 
 Device::~Device() {
@@ -127,12 +76,10 @@
 }
 
 char* Device::halGetParameters(const char* keys) {
-    Diagnostics::getInstance().checkForErasedHalCblk(this);
     return mDevice->get_parameters(mDevice, keys);
 }
 
 int Device::halSetParameters(const char* keysAndValues) {
-    Diagnostics::getInstance().checkForErasedHalCblk(this);
     return mDevice->set_parameters(mDevice, keysAndValues);
 }
 
diff --git a/audio/2.0/default/Device.h b/audio/2.0/default/Device.h
index 55bd0ab..7738361 100644
--- a/audio/2.0/default/Device.h
+++ b/audio/2.0/default/Device.h
@@ -56,7 +56,7 @@
 using ::android::sp;
 
 struct Device : public IDevice, public ParametersUtil {
-    Device(audio_hw_device_t* device, const char* type);
+    explicit Device(audio_hw_device_t* device);
 
     // Methods from ::android::hardware::audio::V2_0::IDevice follow.
     Return<Result> initCheck()  override;
@@ -101,18 +101,17 @@
     void closeInputStream(audio_stream_in_t* stream);
     void closeOutputStream(audio_stream_out_t* stream);
     audio_hw_device_t* device() const { return mDevice; }
-    const char* type() const { return mType; }
-    uint32_t version() const { return mDevice->common.version; }
 
-   private:
+  private:
     audio_hw_device_t *mDevice;
-    const char* mType;
 
     virtual ~Device();
 
     // Methods from ParametersUtil.
     char* halGetParameters(const char* keys) override;
     int halSetParameters(const char* keysAndValues) override;
+
+    uint32_t version() const { return mDevice->common.version; }
 };
 
 }  // namespace implementation
diff --git a/audio/2.0/default/DevicesFactory.cpp b/audio/2.0/default/DevicesFactory.cpp
index b344968..b913bc7 100644
--- a/audio/2.0/default/DevicesFactory.cpp
+++ b/audio/2.0/default/DevicesFactory.cpp
@@ -86,7 +86,7 @@
                 result = new PrimaryDevice(halDevice);
             } else {
                 result = new ::android::hardware::audio::V2_0::implementation::
-                    Device(halDevice, moduleName);
+                    Device(halDevice);
             }
             retval = Result::OK;
         } else if (halStatus == -EINVAL) {
diff --git a/audio/2.0/default/PrimaryDevice.cpp b/audio/2.0/default/PrimaryDevice.cpp
index 746d873..a4a8206 100644
--- a/audio/2.0/default/PrimaryDevice.cpp
+++ b/audio/2.0/default/PrimaryDevice.cpp
@@ -26,7 +26,8 @@
 namespace implementation {
 
 PrimaryDevice::PrimaryDevice(audio_hw_device_t* device)
-    : mDevice{new Device(device, AUDIO_HARDWARE_MODULE_ID_PRIMARY)} {}
+        : mDevice(new Device(device)) {
+}
 
 PrimaryDevice::~PrimaryDevice() {}
 
diff --git a/audio/2.0/vts/Android.mk b/audio/2.0/vts/Android.mk
new file mode 100644
index 0000000..7a16792
--- /dev/null
+++ b/audio/2.0/vts/Android.mk
@@ -0,0 +1,3 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/audio/2.0/vts/functional/Android.bp b/audio/2.0/vts/functional/Android.bp
deleted file mode 100644
index f5ab76f..0000000
--- a/audio/2.0/vts/functional/Android.bp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// Copyright (C) 2017 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-cc_test {
-    name: "VtsHalAudioV2_0TargetTest",
-    defaults: ["hidl_defaults"],
-    srcs: ["AudioPrimaryHidlHalTest.cpp"],
-    shared_libs: [
-        "libbase",
-        "liblog",
-        "libhidlbase",
-        "libhidltransport",
-        "libutils",
-        "libcutils",
-        "android.hardware.audio@2.0",
-        "android.hardware.audio.common@2.0",
-    ],
-    static_libs: ["VtsHalHidlTargetTestBase"],
-    cflags: [
-        "-O0",
-        "-g",
-        "-Wall",
-        "-Wextra",
-        "-Werror",
-    ],
-}
diff --git a/audio/2.0/vts/functional/Android.mk b/audio/2.0/vts/functional/Android.mk
new file mode 100644
index 0000000..db08dde
--- /dev/null
+++ b/audio/2.0/vts/functional/Android.mk
@@ -0,0 +1,42 @@
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_CLANG := true
+LOCAL_MODULE := VtsHalAudioV2_0TargetTest
+LOCAL_CPPFLAGS := -O0 -g -Wall -Wextra -Werror
+LOCAL_SRC_FILES := \
+    AudioPrimaryHidlHalTest.cpp \
+    ValidateAudioConfiguration.cpp \
+    utility/ValidateXml.cpp
+
+LOCAL_C_INCLUDES := external/libxml2/include
+
+LOCAL_STATIC_LIBRARIES := VtsHalHidlTargetTestBase
+LOCAL_SHARED_LIBRARIES := \
+    libbase \
+    liblog \
+    libhidlbase \
+    libhidltransport \
+    libutils \
+    libcutils \
+    libxml2 \
+    libicuuc \
+    android.hardware.audio@2.0 \
+    android.hardware.audio.common@2.0 \
+
+include $(BUILD_NATIVE_TEST)
diff --git a/audio/2.0/vts/functional/ValidateAudioConfiguration.cpp b/audio/2.0/vts/functional/ValidateAudioConfiguration.cpp
new file mode 100644
index 0000000..01324c8
--- /dev/null
+++ b/audio/2.0/vts/functional/ValidateAudioConfiguration.cpp
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "utility/ValidateXml.h"
+
+TEST(CheckConfig, audioPolicyConfigurationValidation) {
+    ASSERT_VALID_XML("/vendor/etc/audio_policy_configuration.xml",
+                     "/data/local/tmp/audio_policy_configuration.xsd");
+}
diff --git a/audio/2.0/vts/functional/utility/ValidateXml.cpp b/audio/2.0/vts/functional/utility/ValidateXml.cpp
new file mode 100644
index 0000000..ff08d2d
--- /dev/null
+++ b/audio/2.0/vts/functional/utility/ValidateXml.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "ValidateAudioConfig"
+#include <utils/Log.h>
+
+#define LIBXML_SCHEMAS_ENABLED
+#include <libxml/xmlschemastypes.h>
+#define LIBXML_XINCLUDE_ENABLED
+#include <libxml/xinclude.h>
+
+#include <memory>
+#include <string>
+
+#include "ValidateXml.h"
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace test {
+
+/** Map libxml2 structures to their corresponding deleters. */
+template <class T>
+constexpr void (*xmlDeleter)(T* t);
+template <>
+constexpr auto xmlDeleter<xmlSchema> = xmlSchemaFree;
+template <>
+constexpr auto xmlDeleter<xmlDoc> = xmlFreeDoc;
+template <>
+constexpr auto xmlDeleter<xmlSchemaParserCtxt> = xmlSchemaFreeParserCtxt;
+template <>
+constexpr auto xmlDeleter<xmlSchemaValidCtxt> = xmlSchemaFreeValidCtxt;
+
+/** @return a unique_ptr with the correct deleter for the libxml2 object. */
+template <class T>
+constexpr auto make_xmlUnique(T* t) {
+    // Wrap deleter in lambda to enable empty base optimization
+    auto deleter = [](T* t) { xmlDeleter<T>(t); };
+    return std::unique_ptr<T, decltype(deleter)>{t, deleter};
+}
+
+/** Class that handles libxml2 initialization and cleanup. NOT THREAD SAFE*/
+struct Libxml2Global {
+    Libxml2Global() {
+        xmlLineNumbersDefault(1);  // Better error message
+        xmlSetGenericErrorFunc(this, errorCb);
+    }
+    ~Libxml2Global() {
+        // TODO: check if all those cleanup are needed
+        xmlSetGenericErrorFunc(nullptr, nullptr);
+        xmlSchemaCleanupTypes();
+        xmlCleanupParser();
+        xmlCleanupThreads();
+    }
+
+    const std::string& getErrors() { return errors; }
+
+   private:
+    static void errorCb(void* ctxt, const char* msg, ...) {
+        auto* self = static_cast<Libxml2Global*>(ctxt);
+        va_list args;
+        va_start(args, msg);
+
+        char* formatedMsg;
+        if (vasprintf(&formatedMsg, msg, args) >= 0) {
+            LOG_PRI(ANDROID_LOG_ERROR, LOG_TAG, "%s", formatedMsg);
+            self->errors += "Error: ";
+            self->errors += formatedMsg;
+        }
+        free(formatedMsg);
+
+        va_end(args);
+    }
+    std::string errors;
+};
+
+::testing::AssertionResult validateXml(const char* xmlFilePathExpr,
+                                       const char* xsdFilePathExpr,
+                                       const char* xmlFilePath,
+                                       const char* xsdFilePath) {
+    Libxml2Global libxml2;
+
+    auto context = [&]() {
+        return std::string() + "    While validating: " + xmlFilePathExpr +
+               "\n          Which is: " + xmlFilePath +
+               "\nAgainst the schema: " + xsdFilePathExpr +
+               "\n          Which is: " + xsdFilePath + "Libxml2 errors\n" +
+               libxml2.getErrors();
+    };
+
+    auto schemaParserCtxt = make_xmlUnique(xmlSchemaNewParserCtxt(xsdFilePath));
+    auto schema = make_xmlUnique(xmlSchemaParse(schemaParserCtxt.get()));
+    if (schema == nullptr) {
+        return ::testing::AssertionFailure() << "Failed to parse schema (xsd)\n"
+                                             << context();
+    }
+
+    auto doc = make_xmlUnique(xmlReadFile(xmlFilePath, nullptr, 0));
+    if (doc == nullptr) {
+        return ::testing::AssertionFailure() << "Failed to parse xml\n"
+                                             << context();
+    }
+
+    if (xmlXIncludeProcess(doc.get()) == -1) {
+        return ::testing::AssertionFailure()
+               << "Failed to resolve xincludes in xml\n"
+               << context();
+    }
+
+    auto schemaCtxt = make_xmlUnique(xmlSchemaNewValidCtxt(schema.get()));
+    int ret = xmlSchemaValidateDoc(schemaCtxt.get(), doc.get());
+    if (ret > 0) {
+        return ::testing::AssertionFailure()
+               << "xml is not valid according to the xsd.\n"
+               << context();
+    }
+    if (ret < 0) {
+        return ::testing::AssertionFailure() << "Internal or API error\n"
+                                             << context();
+    }
+
+    return ::testing::AssertionSuccess();
+}
+
+}  // namespace test
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
diff --git a/audio/2.0/vts/functional/utility/ValidateXml.h b/audio/2.0/vts/functional/utility/ValidateXml.h
new file mode 100644
index 0000000..619dd40
--- /dev/null
+++ b/audio/2.0/vts/functional/utility/ValidateXml.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_HARDWARE_AUDIO_TEST_VALIDATEXML
+#define ANDROID_HARDWARE_AUDIO_TEST_VALIDATEXML
+
+#include <gtest/gtest.h>
+
+namespace android {
+namespace hardware {
+namespace audio {
+namespace test {
+
+/** Validate the provided XmlFile with the provided xsdFile.
+ * Intended to use with ASSERT_PRED_FORMAT2 as such:
+ *   ASSERT_PRED_FORMAT2(validateXml, pathToXml, pathToXsd);
+ * See ASSERT_VALID_XML for a helper macro.
+ */
+::testing::AssertionResult validateXml(const char* xmlFilePathExpr,
+                                       const char* xsdFilePathExpr,
+                                       const char* xmlFilePath,
+                                       const char* xsdPathName);
+
+/** Helper gtest ASSERT to test xml validity against an xsd. */
+#define ASSERT_VALID_XML(xmlFilePath, xsdFilePath)                     \
+    ASSERT_PRED_FORMAT2(::android::hardware::audio::test::validateXml, \
+                        xmlFilePath, xsdFilePath)
+
+}  // namespace test
+}  // namespace audio
+}  // namespace hardware
+}  // namespace android
+
+#endif  // ANDROID_HARDWARE_AUDIO_TEST_VALIDATEXML
diff --git a/audio/Android.bp b/audio/Android.bp
index c3c2be1..abb2bbb 100644
--- a/audio/Android.bp
+++ b/audio/Android.bp
@@ -1,7 +1,6 @@
 // This is an autogenerated file, do not edit.
 subdirs = [
     "2.0",
-    "2.0/vts/functional",
     "common/2.0",
     "common/2.0/default",
     "effect/2.0",
diff --git a/audio/effect/2.0/vts/functional/VtsHalAudioEffectV2_0TargetTest.cpp b/audio/effect/2.0/vts/functional/VtsHalAudioEffectV2_0TargetTest.cpp
index 940bb4e..f069c46 100644
--- a/audio/effect/2.0/vts/functional/VtsHalAudioEffectV2_0TargetTest.cpp
+++ b/audio/effect/2.0/vts/functional/VtsHalAudioEffectV2_0TargetTest.cpp
@@ -450,16 +450,13 @@
 }
 
 TEST_F(AudioEffectHidlTest, Offload) {
-  description("Verify that calling Offload method either works or returns not supported");
+  description("Verify that calling Offload method does not crash");
   EffectOffloadParameter offloadParam;
   offloadParam.isOffload = false;
   offloadParam.ioHandle =
       static_cast<int>(AudioHandleConsts::AUDIO_IO_HANDLE_NONE);
   Return<Result> ret = effect->offload(offloadParam);
   EXPECT_TRUE(ret.isOk());
-  EXPECT_TRUE(Result::OK == ret || Result::NOT_SUPPORTED == ret)
-          << "Expected OK or NOT_SUPPORTED, actual value: "
-          << static_cast<int32_t>(static_cast<Result>(ret));
 }
 
 TEST_F(AudioEffectHidlTest, PrepareForProcessing) {
diff --git a/automotive/vehicle/2.0/default/Android.mk b/automotive/vehicle/2.0/default/Android.mk
index 3c56159..6c2de00 100644
--- a/automotive/vehicle/2.0/default/Android.mk
+++ b/automotive/vehicle/2.0/default/Android.mk
@@ -37,13 +37,37 @@
 LOCAL_SHARED_LIBRARIES := \
     libhidlbase \
     libhidltransport \
-    libhwbinder \
     liblog \
     libutils \
     $(vhal_v2_0) \
 
 include $(BUILD_STATIC_LIBRARY)
 
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := $(vhal_v2_0)-manager-lib-shared
+LOCAL_SRC_FILES := \
+    common/src/SubscriptionManager.cpp \
+    common/src/VehicleHalManager.cpp \
+    common/src/VehicleObjectPool.cpp \
+    common/src/VehiclePropertyStore.cpp \
+    common/src/VehicleUtils.cpp \
+
+LOCAL_C_INCLUDES := \
+    $(LOCAL_PATH)/common/include/vhal_v2_0
+
+LOCAL_EXPORT_C_INCLUDE_DIRS := \
+    $(LOCAL_PATH)/common/include
+
+LOCAL_SHARED_LIBRARIES := \
+    libhidlbase \
+    libhidltransport \
+    liblog \
+    libutils \
+    $(vhal_v2_0) \
+
+include $(BUILD_SHARED_LIBRARY)
+
 ###############################################################################
 # Vehicle HAL Protobuf library
 ###############################################################################
@@ -91,7 +115,6 @@
     libbase \
     libhidlbase \
     libhidltransport \
-    libhwbinder \
     liblog \
     libprotobuf-cpp-lite \
     libutils \
@@ -125,7 +148,6 @@
 LOCAL_SHARED_LIBRARIES := \
     libhidlbase \
     libhidltransport \
-    libhwbinder \
     liblog \
     libutils \
     $(vhal_v2_0) \
@@ -152,7 +174,6 @@
     libbase \
     libhidlbase \
     libhidltransport \
-    libhwbinder \
     liblog \
     libprotobuf-cpp-lite \
     libutils \
diff --git a/camera/device/3.2/default/CameraDeviceSession.cpp b/camera/device/3.2/default/CameraDeviceSession.cpp
index 06a6bd0..f33adf8 100644
--- a/camera/device/3.2/default/CameraDeviceSession.cpp
+++ b/camera/device/3.2/default/CameraDeviceSession.cpp
@@ -341,7 +341,7 @@
     batch->mLastFrame = batch->mFirstFrame + batch->mBatchSize - 1;
     batch->mNumPartialResults = mNumPartialResults;
     for (int id : mStreamsToBatch) {
-        batch->mBatchBufs[id] = InflightBatch::BufferBatch();
+        batch->mBatchBufs.emplace(id, batch->mBatchSize);
     }
     Mutex::Autolock _l(mLock);
     mInflightBatches.push_back(batch);
@@ -418,6 +418,29 @@
     return;
 }
 
+void CameraDeviceSession::ResultBatcher::moveStreamBuffer(StreamBuffer&& src, StreamBuffer& dst) {
+    // Only dealing with releaseFence here. Assume buffer/acquireFence are null
+    const native_handle_t* handle = src.releaseFence.getNativeHandle();
+    src.releaseFence = nullptr;
+    dst = src;
+    dst.releaseFence = handle;
+    if (handle != dst.releaseFence.getNativeHandle()) {
+        ALOGE("%s: native handle cloned!", __FUNCTION__);
+    }
+}
+
+void CameraDeviceSession::ResultBatcher::pushStreamBuffer(
+        StreamBuffer&& src, std::vector<StreamBuffer>& dst) {
+    // Only dealing with releaseFence here. Assume buffer/acquireFence are null
+    const native_handle_t* handle = src.releaseFence.getNativeHandle();
+    src.releaseFence = nullptr;
+    dst.push_back(src);
+    dst.back().releaseFence = handle;
+    if (handle != dst.back().releaseFence.getNativeHandle()) {
+        ALOGE("%s: native handle cloned!", __FUNCTION__);
+    }
+}
+
 void CameraDeviceSession::ResultBatcher::sendBatchBuffersLocked(std::shared_ptr<InflightBatch> batch) {
     sendBatchBuffersLocked(batch, mStreamsToBatch);
 }
@@ -444,7 +467,12 @@
     if (batchSize == 0) {
         ALOGW("%s: there is no buffer to be delivered for this batch.", __FUNCTION__);
         for (int streamId : streams) {
-            InflightBatch::BufferBatch& bb = batch->mBatchBufs[streamId];
+            auto it = batch->mBatchBufs.find(streamId);
+            if (it == batch->mBatchBufs.end()) {
+                ALOGE("%s: cannot find stream %d in batched buffers!", __FUNCTION__, streamId);
+                return;
+            }
+            InflightBatch::BufferBatch& bb = it->second;
             bb.mDelivered = true;
         }
         return;
@@ -460,21 +488,35 @@
         results[i].inputBuffer.bufferId = 0;
         results[i].inputBuffer.buffer = nullptr;
         std::vector<StreamBuffer> outBufs;
+        outBufs.reserve(streams.size());
         for (int streamId : streams) {
-            InflightBatch::BufferBatch& bb = batch->mBatchBufs[streamId];
+            auto it = batch->mBatchBufs.find(streamId);
+            if (it == batch->mBatchBufs.end()) {
+                ALOGE("%s: cannot find stream %d in batched buffers!", __FUNCTION__, streamId);
+                return;
+            }
+            InflightBatch::BufferBatch& bb = it->second;
             if (bb.mDelivered) {
                 continue;
             }
             if (i < bb.mBuffers.size()) {
-                outBufs.push_back(bb.mBuffers[i]);
+                pushStreamBuffer(std::move(bb.mBuffers[i]), outBufs);
             }
         }
-        results[i].outputBuffers = outBufs;
+        results[i].outputBuffers.resize(outBufs.size());
+        for (size_t j = 0; j < outBufs.size(); j++) {
+            moveStreamBuffer(std::move(outBufs[j]), results[i].outputBuffers[j]);
+        }
     }
     invokeProcessCaptureResultCallback(results, /* tryWriteFmq */false);
     freeReleaseFences(results);
     for (int streamId : streams) {
-        InflightBatch::BufferBatch& bb = batch->mBatchBufs[streamId];
+        auto it = batch->mBatchBufs.find(streamId);
+        if (it == batch->mBatchBufs.end()) {
+            ALOGE("%s: cannot find stream %d in batched buffers!", __FUNCTION__, streamId);
+            return;
+        }
+        InflightBatch::BufferBatch& bb = it->second;
         bb.mDelivered = true;
         bb.mBuffers.clear();
     }
@@ -613,7 +655,9 @@
 }
 
 void CameraDeviceSession::ResultBatcher::processOneCaptureResult(CaptureResult& result) {
-    hidl_vec<CaptureResult> results = {result};
+    hidl_vec<CaptureResult> results;
+    results.resize(1);
+    results[0] = std::move(result);
     invokeProcessCaptureResultCallback(results, /* tryWriteFmq */true);
     freeReleaseFences(results);
     return;
@@ -650,10 +694,10 @@
             auto it = batch->mBatchBufs.find(buffer.streamId);
             if (it != batch->mBatchBufs.end()) {
                 InflightBatch::BufferBatch& bb = it->second;
-                bb.mBuffers.push_back(buffer);
+                pushStreamBuffer(std::move(buffer), bb.mBuffers);
                 filledStreams.push_back(buffer.streamId);
             } else {
-                nonBatchedBuffers.push_back(buffer);
+                pushStreamBuffer(std::move(buffer), nonBatchedBuffers);
             }
         }
 
@@ -662,8 +706,12 @@
             CaptureResult nonBatchedResult;
             nonBatchedResult.frameNumber = result.frameNumber;
             nonBatchedResult.fmqResultSize = 0;
-            nonBatchedResult.outputBuffers = nonBatchedBuffers;
-            nonBatchedResult.inputBuffer = result.inputBuffer;
+            nonBatchedResult.outputBuffers.resize(nonBatchedBuffers.size());
+            for (size_t i = 0; i < nonBatchedBuffers.size(); i++) {
+                moveStreamBuffer(
+                        std::move(nonBatchedBuffers[i]), nonBatchedResult.outputBuffers[i]);
+            }
+            moveStreamBuffer(std::move(result.inputBuffer), nonBatchedResult.inputBuffer);
             nonBatchedResult.partialResult = 0; // 0 for buffer only results
             processOneCaptureResult(nonBatchedResult);
         }
diff --git a/camera/device/3.2/default/CameraDeviceSession.h b/camera/device/3.2/default/CameraDeviceSession.h
index d559c48..fb3fc02 100644
--- a/camera/device/3.2/default/CameraDeviceSession.h
+++ b/camera/device/3.2/default/CameraDeviceSession.h
@@ -184,6 +184,9 @@
             std::vector<NotifyMsg> mShutterMsgs;
 
             struct BufferBatch {
+                BufferBatch(uint32_t batchSize) {
+                    mBuffers.reserve(batchSize);
+                }
                 bool mDelivered = false;
                 // This currently assumes every batched request will output to the batched stream
                 // and since HAL must always send buffers in order, no frameNumber tracking is
@@ -241,6 +244,11 @@
         void processOneCaptureResult(CaptureResult& result);
         void invokeProcessCaptureResultCallback(hidl_vec<CaptureResult> &results, bool tryWriteFmq);
 
+        // move/push function avoids "hidl_handle& operator=(hidl_handle&)", which clones native
+        // handle
+        void moveStreamBuffer(StreamBuffer&& src, StreamBuffer& dst);
+        void pushStreamBuffer(StreamBuffer&& src, std::vector<StreamBuffer>& dst);
+
         // Protect access to mInflightBatches, mNumPartialResults and mStreamsToBatch
         // processCaptureRequest, processCaptureResult, notify will compete for this lock
         // Do NOT issue HIDL IPCs while holding this lock (except when HAL reports error)
diff --git a/configstore/utils/Android.bp b/configstore/utils/Android.bp
index 2c8aad6..a4cad66 100644
--- a/configstore/utils/Android.bp
+++ b/configstore/utils/Android.bp
@@ -16,6 +16,7 @@
 
 cc_library_shared {
     name: "android.hardware.configstore-utils",
+    vendor_available: true,
     defaults: ["hidl_defaults"],
 
     srcs: [ "ConfigStoreUtils.cpp" ],
diff --git a/contexthub/1.0/default/Contexthub.cpp b/contexthub/1.0/default/Contexthub.cpp
index 4a6b3f2..bf45900 100644
--- a/contexthub/1.0/default/Contexthub.cpp
+++ b/contexthub/1.0/default/Contexthub.cpp
@@ -38,6 +38,7 @@
 Contexthub::Contexthub()
         : mInitCheck(NO_INIT),
           mContextHubModule(nullptr),
+          mDeathRecipient(new DeathRecipient(this)),
           mIsTransactionPending(false) {
     const hw_module_t *module;
 
@@ -96,7 +97,7 @@
             c.stoppedPowerDrawMw = hubArray[i].stopped_power_draw_mw;
             c.sleepPowerDrawMw = hubArray[i].sleep_power_draw_mw;
 
-            info.callBack = nullptr;
+            info.callback = nullptr;
             info.osAppName = hubArray[i].os_app_name;
             mCachedHubInfo[hubArray[i].hub_id] = info;
 
@@ -110,6 +111,16 @@
     return Void();
 }
 
+Contexthub::DeathRecipient::DeathRecipient(sp<Contexthub> contexthub)
+        : mContexthub(contexthub) {}
+
+void Contexthub::DeathRecipient::serviceDied(
+        uint64_t cookie,
+        const wp<::android::hidl::base::V1_0::IBase>& /*who*/) {
+    uint32_t hubId = static_cast<uint32_t>(cookie);
+    mContexthub->handleServiceDeath(hubId);
+}
+
 bool Contexthub::isValidHubId(uint32_t hubId) {
     if (!mCachedHubInfo.count(hubId)) {
         ALOGW("Hub information not found for hubId %" PRIu32, hubId);
@@ -123,7 +134,7 @@
     if (!isValidHubId(hubId)) {
         return nullptr;
     } else {
-        return mCachedHubInfo[hubId].callBack;
+        return mCachedHubInfo[hubId].callback;
     }
 }
 
@@ -193,8 +204,22 @@
                                                      contextHubCb,
                                                      this) == 0) {
         // Initialized && valid hub && subscription successful
+        if (mCachedHubInfo[hubId].callback != nullptr) {
+            ALOGD("Modifying callback for hubId %" PRIu32, hubId);
+            mCachedHubInfo[hubId].callback->unlinkToDeath(mDeathRecipient);
+        }
+
+        mCachedHubInfo[hubId].callback = cb;
+        if (cb != nullptr) {
+            Return<bool> linkResult = cb->linkToDeath(mDeathRecipient, hubId);
+            bool linkSuccess = linkResult.isOk() ?
+                static_cast<bool>(linkResult) : false;
+            if (!linkSuccess) {
+                ALOGW("Couldn't link death recipient for hubId %" PRIu32,
+                      hubId);
+            }
+        }
         retVal = Result::OK;
-        mCachedHubInfo[hubId].callBack = cb;
     } else {
         // Initalized && valid hubId - but subscription unsuccessful
         // This is likely an internal error in the HAL implementation, but we
@@ -309,6 +334,16 @@
       return retVal;
 }
 
+void Contexthub::handleServiceDeath(uint32_t hubId) {
+    ALOGI("Callback/service died for hubId %" PRIu32, hubId);
+    int ret = mContextHubModule->subscribe_messages(hubId, nullptr, nullptr);
+    if (ret != 0) {
+        ALOGW("Failed to unregister callback from hubId %" PRIu32 ": %d",
+              hubId, ret);
+    }
+    mCachedHubInfo[hubId].callback.clear();
+}
+
 int Contexthub::contextHubCb(uint32_t hubId,
                              const struct hub_message_t *rxMsg,
                              void *cookie) {
diff --git a/contexthub/1.0/default/Contexthub.h b/contexthub/1.0/default/Contexthub.h
index 236e079..db23ec2 100644
--- a/contexthub/1.0/default/Contexthub.h
+++ b/contexthub/1.0/default/Contexthub.h
@@ -65,14 +65,26 @@
 
     struct CachedHubInformation{
         struct hub_app_name_t osAppName;
-        sp<IContexthubCallback> callBack;
+        sp<IContexthubCallback> callback;
+    };
+
+    class DeathRecipient : public hidl_death_recipient {
+    public:
+        DeathRecipient(const sp<Contexthub> contexthub);
+
+        void serviceDied(
+                uint64_t cookie,
+                const wp<::android::hidl::base::V1_0::IBase>& who) override;
+
+    private:
+        sp<Contexthub> mContexthub;
     };
 
     status_t mInitCheck;
     const struct context_hub_module_t *mContextHubModule;
     std::unordered_map<uint32_t, CachedHubInformation> mCachedHubInfo;
 
-    sp<IContexthubCallback> mCb;
+    sp<DeathRecipient> mDeathRecipient;
     bool mIsTransactionPending;
     uint32_t mTransactionId;
 
@@ -85,6 +97,9 @@
                         const uint8_t *msg,
                         int msgLen);
 
+    // Handle the case where the callback registered for the given hub ID dies
+    void handleServiceDeath(uint32_t hubId);
+
     static int contextHubCb(uint32_t hubId,
                             const struct hub_message_t *rxMsg,
                             void *cookie);
diff --git a/gnss/1.0/default/android.hardware.gnss@1.0-service.rc b/gnss/1.0/default/android.hardware.gnss@1.0-service.rc
index 96638a3..13dc96a 100644
--- a/gnss/1.0/default/android.hardware.gnss@1.0-service.rc
+++ b/gnss/1.0/default/android.hardware.gnss@1.0-service.rc
@@ -1,4 +1,4 @@
 service gnss_service /vendor/bin/hw/android.hardware.gnss@1.0-service
     class main
     user system
-    group system gps
+    group system gps radio
diff --git a/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp b/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp
index fcd4dec..12bfac5 100644
--- a/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp
+++ b/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp
@@ -4008,7 +4008,8 @@
             Begin(KeyPurpose::SIGN, key_blob_, AuthorizationSetBuilder()
                                                    .Digest(Digest::NONE)
                                                    .Padding(PaddingMode::NONE),
-                  &begin_out_params, &op_handle_));
+                  &begin_out_params, &op_handle_))
+            << " (Possibly b/37623742)";
     } else {
         EXPECT_EQ(ErrorCode::OK, Begin(KeyPurpose::SIGN, key_blob_,
                                        AuthorizationSetBuilder()
diff --git a/radio/1.0/vts/functional/Android.bp b/radio/1.0/vts/functional/Android.bp
index 7808de1..5403971 100644
--- a/radio/1.0/vts/functional/Android.bp
+++ b/radio/1.0/vts/functional/Android.bp
@@ -27,7 +27,8 @@
            "radio_hidl_hal_test.cpp",
            "radio_hidl_hal_voice.cpp",
            "radio_response.cpp",
-           "VtsHalRadioV1_0TargetTest.cpp"],
+           "VtsHalRadioV1_0TargetTest.cpp",
+           "vts_test_util.cpp"],
     shared_libs: [
         "libbase",
         "liblog",
@@ -51,7 +52,8 @@
     srcs: ["sap_callback.cpp",
            "sap_hidl_hal_api.cpp",
            "sap_hidl_hal_test.cpp",
-           "VtsHalSapV1_0TargetTest.cpp"],
+           "VtsHalSapV1_0TargetTest.cpp",
+           "vts_test_util.cpp"],
     shared_libs: [
         "libbase",
         "liblog",
diff --git a/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp b/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp
index e7c89d5..59881ef 100644
--- a/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp
+++ b/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp
@@ -17,11 +17,16 @@
 #include <radio_hidl_hal_utils.h>
 
 int main(int argc, char** argv) {
-  ::testing::AddGlobalTestEnvironment(new RadioHidlEnvironment);
-  ::testing::InitGoogleTest(&argc, argv);
+    ::testing::AddGlobalTestEnvironment(new RadioHidlEnvironment);
+    ::testing::InitGoogleTest(&argc, argv);
 
-  int status = RUN_ALL_TESTS();
-  LOG(INFO) << "Test result = " << status;
+    // setup seed for rand function
+    int seedSrand = time(NULL);
+    std::cout << "seed setup for random function (radio):" + std::to_string(seedSrand) << std::endl;
+    srand(seedSrand);
 
-  return status;
+    int status = RUN_ALL_TESTS();
+    LOG(INFO) << "Test result = " << status;
+
+    return status;
 }
\ No newline at end of file
diff --git a/radio/1.0/vts/functional/VtsHalSapV1_0TargetTest.cpp b/radio/1.0/vts/functional/VtsHalSapV1_0TargetTest.cpp
index 5306076..5e5c50c 100644
--- a/radio/1.0/vts/functional/VtsHalSapV1_0TargetTest.cpp
+++ b/radio/1.0/vts/functional/VtsHalSapV1_0TargetTest.cpp
@@ -17,12 +17,17 @@
 #include <sap_hidl_hal_utils.h>
 
 int main(int argc, char** argv) {
-  // Add Sim-access Profile Hidl Environment
-  ::testing::AddGlobalTestEnvironment(new SapHidlEnvironment);
-  ::testing::InitGoogleTest(&argc, argv);
+    // Add Sim-access Profile Hidl Environment
+    ::testing::AddGlobalTestEnvironment(new SapHidlEnvironment);
+    ::testing::InitGoogleTest(&argc, argv);
 
-  int status = RUN_ALL_TESTS();
-  LOG(INFO) << "Test result = " << status;
+    // setup seed for rand function
+    int seedSrand = time(NULL);
+    std::cout << "seed setup for random function (sap):" + std::to_string(seedSrand) << std::endl;
+    srand(seedSrand);
 
-  return status;
+    int status = RUN_ALL_TESTS();
+    LOG(INFO) << "Test result = " << status;
+
+    return status;
 }
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_cell_broadcast.cpp b/radio/1.0/vts/functional/radio_hidl_hal_cell_broadcast.cpp
index bbca9e4..3bf7c9d 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_cell_broadcast.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_cell_broadcast.cpp
@@ -22,165 +22,163 @@
  * Test IRadio.setGsmBroadcastConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, setGsmBroadcastConfig) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  // Create GsmBroadcastSmsConfigInfo #1
-  GsmBroadcastSmsConfigInfo gbSmsConfig1;
-  gbSmsConfig1.fromServiceId = 4352;
-  gbSmsConfig1.toServiceId = 4354;
-  gbSmsConfig1.fromCodeScheme = 0;
-  gbSmsConfig1.toCodeScheme = 255;
-  gbSmsConfig1.selected = true;
+    // Create GsmBroadcastSmsConfigInfo #1
+    GsmBroadcastSmsConfigInfo gbSmsConfig1;
+    gbSmsConfig1.fromServiceId = 4352;
+    gbSmsConfig1.toServiceId = 4354;
+    gbSmsConfig1.fromCodeScheme = 0;
+    gbSmsConfig1.toCodeScheme = 255;
+    gbSmsConfig1.selected = true;
 
-  // Create GsmBroadcastSmsConfigInfo #2
-  GsmBroadcastSmsConfigInfo gbSmsConfig2;
-  gbSmsConfig2.fromServiceId = 4356;
-  gbSmsConfig2.toServiceId = 4356;
-  gbSmsConfig2.fromCodeScheme = 0;
-  gbSmsConfig2.toCodeScheme = 255;
-  gbSmsConfig2.selected = true;
+    // Create GsmBroadcastSmsConfigInfo #2
+    GsmBroadcastSmsConfigInfo gbSmsConfig2;
+    gbSmsConfig2.fromServiceId = 4356;
+    gbSmsConfig2.toServiceId = 4356;
+    gbSmsConfig2.fromCodeScheme = 0;
+    gbSmsConfig2.toCodeScheme = 255;
+    gbSmsConfig2.selected = true;
 
-  // Create GsmBroadcastSmsConfigInfo #3
-  GsmBroadcastSmsConfigInfo gbSmsConfig3;
-  gbSmsConfig3.fromServiceId = 4370;
-  gbSmsConfig3.toServiceId = 4379;
-  gbSmsConfig3.fromCodeScheme = 0;
-  gbSmsConfig3.toCodeScheme = 255;
-  gbSmsConfig3.selected = true;
+    // Create GsmBroadcastSmsConfigInfo #3
+    GsmBroadcastSmsConfigInfo gbSmsConfig3;
+    gbSmsConfig3.fromServiceId = 4370;
+    gbSmsConfig3.toServiceId = 4379;
+    gbSmsConfig3.fromCodeScheme = 0;
+    gbSmsConfig3.toCodeScheme = 255;
+    gbSmsConfig3.selected = true;
 
-  // Create GsmBroadcastSmsConfigInfo #4
-  GsmBroadcastSmsConfigInfo gbSmsConfig4;
-  gbSmsConfig4.fromServiceId = 4383;
-  gbSmsConfig4.toServiceId = 4391;
-  gbSmsConfig4.fromCodeScheme = 0;
-  gbSmsConfig4.toCodeScheme = 255;
-  gbSmsConfig4.selected = true;
+    // Create GsmBroadcastSmsConfigInfo #4
+    GsmBroadcastSmsConfigInfo gbSmsConfig4;
+    gbSmsConfig4.fromServiceId = 4383;
+    gbSmsConfig4.toServiceId = 4391;
+    gbSmsConfig4.fromCodeScheme = 0;
+    gbSmsConfig4.toCodeScheme = 255;
+    gbSmsConfig4.selected = true;
 
-  // Create GsmBroadcastSmsConfigInfo #5
-  GsmBroadcastSmsConfigInfo gbSmsConfig5;
-  gbSmsConfig5.fromServiceId = 4392;
-  gbSmsConfig5.toServiceId = 4392;
-  gbSmsConfig5.fromCodeScheme = 0;
-  gbSmsConfig5.toCodeScheme = 255;
-  gbSmsConfig5.selected = true;
+    // Create GsmBroadcastSmsConfigInfo #5
+    GsmBroadcastSmsConfigInfo gbSmsConfig5;
+    gbSmsConfig5.fromServiceId = 4392;
+    gbSmsConfig5.toServiceId = 4392;
+    gbSmsConfig5.fromCodeScheme = 0;
+    gbSmsConfig5.toCodeScheme = 255;
+    gbSmsConfig5.selected = true;
 
-  android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>
-      gsmBroadcastSmsConfigsInfoList = {
-          gbSmsConfig1, gbSmsConfig2, gbSmsConfig3, gbSmsConfig4, gbSmsConfig5};
+    android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo> gsmBroadcastSmsConfigsInfoList = {
+        gbSmsConfig1, gbSmsConfig2, gbSmsConfig3, gbSmsConfig4, gbSmsConfig5};
 
-  radio->setGsmBroadcastConfig(++serial, gsmBroadcastSmsConfigsInfoList);
+    radio->setGsmBroadcastConfig(serial, gsmBroadcastSmsConfigsInfoList);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getGsmBroadcastConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, getGsmBroadcastConfig) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  radio->getGsmBroadcastConfig(++serial);
+    radio->getGsmBroadcastConfig(serial);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setCdmaBroadcastConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, setCdmaBroadcastConfig) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  CdmaBroadcastSmsConfigInfo cbSmsConfig;
-  cbSmsConfig.serviceCategory = 4096;
-  cbSmsConfig.language = 1;
-  cbSmsConfig.selected = true;
+    CdmaBroadcastSmsConfigInfo cbSmsConfig;
+    cbSmsConfig.serviceCategory = 4096;
+    cbSmsConfig.language = 1;
+    cbSmsConfig.selected = true;
 
-  android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>
-      cdmaBroadcastSmsConfigInfoList = {cbSmsConfig};
+    android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo> cdmaBroadcastSmsConfigInfoList = {
+        cbSmsConfig};
 
-  radio->setCdmaBroadcastConfig(++serial, cdmaBroadcastSmsConfigInfoList);
+    radio->setCdmaBroadcastConfig(serial, cdmaBroadcastSmsConfigInfoList);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 }
 
 /*
  * Test IRadio.getCdmaBroadcastConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, getCdmaBroadcastConfig) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  radio->getCdmaBroadcastConfig(++serial);
+    radio->getCdmaBroadcastConfig(serial);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError());
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError());
+    }
 }
 
 /*
  * Test IRadio.setCdmaBroadcastActivation() for the response returned.
  */
 TEST_F(RadioHidlTest, setCdmaBroadcastActivation) {
-  int serial = 0;
-  bool activate = false;
+    int serial = GetRandomSerialNumber();
+    bool activate = false;
 
-  radio->setCdmaBroadcastActivation(++serial, activate);
+    radio->setCdmaBroadcastActivation(serial, activate);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 }
 
 /*
  * Test IRadio.setGsmBroadcastActivation() for the response returned.
  */
 TEST_F(RadioHidlTest, setGsmBroadcastActivation) {
-  int serial = 0;
-  bool activate = false;
+    int serial = GetRandomSerialNumber();
+    bool activate = false;
 
-  radio->setGsmBroadcastActivation(++serial, activate);
+    radio->setGsmBroadcastActivation(serial, activate);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::OPERATION_NOT_ALLOWED);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::OPERATION_NOT_ALLOWED);
+    }
 }
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_data.cpp b/radio/1.0/vts/functional/radio_hidl_hal_data.cpp
index 4eeabe8..108676b 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_data.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_data.cpp
@@ -22,209 +22,204 @@
  * Test IRadio.getDataRegistrationState() for the response returned.
  */
 TEST_F(RadioHidlTest, getDataRegistrationState) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  radio->getDataRegistrationState(++serial);
+    radio->getDataRegistrationState(serial);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+    }
 }
 
 /*
  * Test IRadio.setupDataCall() for the response returned.
  */
 TEST_F(RadioHidlTest, setupDataCall) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  RadioTechnology radioTechnology = RadioTechnology::LTE;
+    RadioTechnology radioTechnology = RadioTechnology::LTE;
 
-  DataProfileInfo dataProfileInfo;
-  memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
-  dataProfileInfo.profileId = DataProfileId::IMS;
-  dataProfileInfo.apn = hidl_string("VZWIMS");
-  dataProfileInfo.protocol = hidl_string("IPV4V6");
-  dataProfileInfo.roamingProtocol = hidl_string("IPV6");
-  dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
-  dataProfileInfo.user = "";
-  dataProfileInfo.password = "";
-  dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
-  dataProfileInfo.maxConnsTime = 300;
-  dataProfileInfo.maxConns = 20;
-  dataProfileInfo.waitTime = 0;
-  dataProfileInfo.enabled = true;
-  dataProfileInfo.supportedApnTypesBitmap = 320;
-  dataProfileInfo.bearerBitmap = 161543;
-  dataProfileInfo.mtu = 0;
-  dataProfileInfo.mvnoType = MvnoType::NONE;
-  dataProfileInfo.mvnoMatchData = hidl_string();
+    DataProfileInfo dataProfileInfo;
+    memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
+    dataProfileInfo.profileId = DataProfileId::IMS;
+    dataProfileInfo.apn = hidl_string("VZWIMS");
+    dataProfileInfo.protocol = hidl_string("IPV4V6");
+    dataProfileInfo.roamingProtocol = hidl_string("IPV6");
+    dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
+    dataProfileInfo.user = "";
+    dataProfileInfo.password = "";
+    dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
+    dataProfileInfo.maxConnsTime = 300;
+    dataProfileInfo.maxConns = 20;
+    dataProfileInfo.waitTime = 0;
+    dataProfileInfo.enabled = true;
+    dataProfileInfo.supportedApnTypesBitmap = 320;
+    dataProfileInfo.bearerBitmap = 161543;
+    dataProfileInfo.mtu = 0;
+    dataProfileInfo.mvnoType = MvnoType::NONE;
+    dataProfileInfo.mvnoMatchData = hidl_string();
 
-  bool modemCognitive = false;
-  bool roamingAllowed = false;
-  bool isRoaming = false;
+    bool modemCognitive = false;
+    bool roamingAllowed = false;
+    bool isRoaming = false;
 
-  radio->setupDataCall(++serial, radioTechnology, dataProfileInfo,
-                       modemCognitive, roamingAllowed, isRoaming);
+    radio->setupDataCall(serial, radioTechnology, dataProfileInfo, modemCognitive, roamingAllowed,
+                         isRoaming);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE ||
-                  radioRsp->rspInfo.error ==
-                      RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW ||
-                  radioRsp->rspInfo.error ==
-                      RadioError::OP_NOT_ALLOWED_DURING_VOICE_CALL ||
-                  CheckOEMError());
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE ||
+                    radioRsp->rspInfo.error == RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW ||
+                    radioRsp->rspInfo.error == RadioError::OP_NOT_ALLOWED_DURING_VOICE_CALL ||
+                    CheckOEMError());
+    }
 }
 
 /*
  * Test IRadio.deactivateDataCall() for the response returned.
  */
 TEST_F(RadioHidlTest, deactivateDataCall) {
-  int serial = 0;
-  int cid = 1;
-  bool reasonRadioShutDown = false;
+    int serial = GetRandomSerialNumber();
+    int cid = 1;
+    bool reasonRadioShutDown = false;
 
-  radio->deactivateDataCall(++serial, cid, reasonRadioShutDown);
+    radio->deactivateDataCall(serial, cid, reasonRadioShutDown);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      EXPECT_EQ(RadioError::INVALID_CALL_ID, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        EXPECT_EQ(RadioError::INVALID_CALL_ID, radioRsp->rspInfo.error);
+    }
 }
 
 /*
  * Test IRadio.getDataCallList() for the response returned.
  */
 TEST_F(RadioHidlTest, getDataCallList) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  radio->getDataCallList(++serial);
+    radio->getDataCallList(serial);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE);
+    }
 }
 
 /*
  * Test IRadio.setInitialAttachApn() for the response returned.
  */
 TEST_F(RadioHidlTest, setInitialAttachApn) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  DataProfileInfo dataProfileInfo;
-  memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
-  dataProfileInfo.profileId = DataProfileId::IMS;
-  dataProfileInfo.apn = hidl_string("VZWIMS");
-  dataProfileInfo.protocol = hidl_string("IPV4V6");
-  dataProfileInfo.roamingProtocol = hidl_string("IPV6");
-  dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
-  dataProfileInfo.user = "";
-  dataProfileInfo.password = "";
-  dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
-  dataProfileInfo.maxConnsTime = 300;
-  dataProfileInfo.maxConns = 20;
-  dataProfileInfo.waitTime = 0;
-  dataProfileInfo.enabled = true;
-  dataProfileInfo.supportedApnTypesBitmap = 320;
-  dataProfileInfo.bearerBitmap = 161543;
-  dataProfileInfo.mtu = 0;
-  dataProfileInfo.mvnoType = MvnoType::NONE;
-  dataProfileInfo.mvnoMatchData = hidl_string();
+    DataProfileInfo dataProfileInfo;
+    memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
+    dataProfileInfo.profileId = DataProfileId::IMS;
+    dataProfileInfo.apn = hidl_string("VZWIMS");
+    dataProfileInfo.protocol = hidl_string("IPV4V6");
+    dataProfileInfo.roamingProtocol = hidl_string("IPV6");
+    dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
+    dataProfileInfo.user = "";
+    dataProfileInfo.password = "";
+    dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
+    dataProfileInfo.maxConnsTime = 300;
+    dataProfileInfo.maxConns = 20;
+    dataProfileInfo.waitTime = 0;
+    dataProfileInfo.enabled = true;
+    dataProfileInfo.supportedApnTypesBitmap = 320;
+    dataProfileInfo.bearerBitmap = 161543;
+    dataProfileInfo.mtu = 0;
+    dataProfileInfo.mvnoType = MvnoType::NONE;
+    dataProfileInfo.mvnoMatchData = hidl_string();
 
-  bool modemCognitive = true;
-  bool isRoaming = false;
+    bool modemCognitive = true;
+    bool isRoaming = false;
 
-  radio->setInitialAttachApn(++serial, dataProfileInfo, modemCognitive,
-                             isRoaming);
+    radio->setInitialAttachApn(serial, dataProfileInfo, modemCognitive, isRoaming);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE ||
-                  radioRsp->rspInfo.error ==
-                      RadioError::SUBSCRIPTION_NOT_AVAILABLE ||
-                  CheckOEMError());
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE ||
+                    radioRsp->rspInfo.error == RadioError::SUBSCRIPTION_NOT_AVAILABLE ||
+                    CheckOEMError());
+    }
 }
 
 /*
  * Test IRadio.setDataAllowed() for the response returned.
  */
 TEST_F(RadioHidlTest, setDataAllowed) {
-  int serial = 0;
-  bool allow = true;
+    int serial = GetRandomSerialNumber();
+    bool allow = true;
 
-  radio->setDataAllowed(++serial, allow);
+    radio->setDataAllowed(serial, allow);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+    }
 }
 
 /*
  * Test IRadio.setDataProfile() for the response returned.
  */
 TEST_F(RadioHidlTest, setDataProfile) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  // Create a dataProfileInfo
-  DataProfileInfo dataProfileInfo;
-  memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
-  dataProfileInfo.profileId = DataProfileId::IMS;
-  dataProfileInfo.apn = hidl_string("VZWIMS");
-  dataProfileInfo.protocol = hidl_string("IPV4V6");
-  dataProfileInfo.roamingProtocol = hidl_string("IPV6");
-  dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
-  dataProfileInfo.user = "";
-  dataProfileInfo.password = "";
-  dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
-  dataProfileInfo.maxConnsTime = 300;
-  dataProfileInfo.maxConns = 20;
-  dataProfileInfo.waitTime = 0;
-  dataProfileInfo.enabled = true;
-  dataProfileInfo.supportedApnTypesBitmap = 320;
-  dataProfileInfo.bearerBitmap = 161543;
-  dataProfileInfo.mtu = 0;
-  dataProfileInfo.mvnoType = MvnoType::NONE;
-  dataProfileInfo.mvnoMatchData = hidl_string();
+    // Create a dataProfileInfo
+    DataProfileInfo dataProfileInfo;
+    memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
+    dataProfileInfo.profileId = DataProfileId::IMS;
+    dataProfileInfo.apn = hidl_string("VZWIMS");
+    dataProfileInfo.protocol = hidl_string("IPV4V6");
+    dataProfileInfo.roamingProtocol = hidl_string("IPV6");
+    dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
+    dataProfileInfo.user = "";
+    dataProfileInfo.password = "";
+    dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
+    dataProfileInfo.maxConnsTime = 300;
+    dataProfileInfo.maxConns = 20;
+    dataProfileInfo.waitTime = 0;
+    dataProfileInfo.enabled = true;
+    dataProfileInfo.supportedApnTypesBitmap = 320;
+    dataProfileInfo.bearerBitmap = 161543;
+    dataProfileInfo.mtu = 0;
+    dataProfileInfo.mvnoType = MvnoType::NONE;
+    dataProfileInfo.mvnoMatchData = hidl_string();
 
-  // Create a dataProfileInfoList
-  android::hardware::hidl_vec<DataProfileInfo> dataProfileInfoList = {
-      dataProfileInfo};
+    // Create a dataProfileInfoList
+    android::hardware::hidl_vec<DataProfileInfo> dataProfileInfoList = {dataProfileInfo};
 
-  bool isRoadming = false;
+    bool isRoadming = false;
 
-  radio->setDataProfile(++serial, dataProfileInfoList, isRoadming);
+    radio->setDataProfile(serial, dataProfileInfoList, isRoadming);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    // TODO(shuoq): Will add error check when we know the expected error from QC
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        // TODO(shuoq): Will add error check when we know the expected error from QC
+    }
 }
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp b/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp
index 8082bca..a8857c3 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp
@@ -20,311 +20,303 @@
  * Test IRadio.getIccCardStatus() for the response returned.
  */
 TEST_F(RadioHidlTest, getIccCardStatus) {
-  EXPECT_LE(cardStatus.applications.size(),
-            (unsigned int)RadioConst::CARD_MAX_APPS);
-  EXPECT_LT(cardStatus.gsmUmtsSubscriptionAppIndex,
-            (int)RadioConst::CARD_MAX_APPS);
-  EXPECT_LT(cardStatus.cdmaSubscriptionAppIndex,
-            (int)RadioConst::CARD_MAX_APPS);
-  EXPECT_LT(cardStatus.imsSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
+    EXPECT_LE(cardStatus.applications.size(), (unsigned int)RadioConst::CARD_MAX_APPS);
+    EXPECT_LT(cardStatus.gsmUmtsSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
+    EXPECT_LT(cardStatus.cdmaSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
+    EXPECT_LT(cardStatus.imsSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
 }
 
 /*
  * Test IRadio.supplyIccPinForApp() for the response returned
  */
 TEST_F(RadioHidlTest, supplyIccPinForApp) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
-  // 3GPP2 apps only
-  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
-    if (cardStatus.applications[i].appType == AppType::SIM ||
-        cardStatus.applications[i].appType == AppType::USIM ||
-        cardStatus.applications[i].appType == AppType::RUIM ||
-        cardStatus.applications[i].appType == AppType::CSIM) {
-      radio->supplyIccPinForApp(++serial, hidl_string("test1"),
-                                cardStatus.applications[i].aidPtr);
-      EXPECT_EQ(std::cv_status::no_timeout, wait());
-      EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-      EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-      EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+    // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+    // 3GPP2 apps only
+    for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+        if (cardStatus.applications[i].appType == AppType::SIM ||
+            cardStatus.applications[i].appType == AppType::USIM ||
+            cardStatus.applications[i].appType == AppType::RUIM ||
+            cardStatus.applications[i].appType == AppType::CSIM) {
+            radio->supplyIccPinForApp(serial, hidl_string("test1"),
+                                      cardStatus.applications[i].aidPtr);
+            EXPECT_EQ(std::cv_status::no_timeout, wait());
+            EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+            EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+            EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+        }
     }
-  }
 }
 
 /*
  * Test IRadio.supplyIccPukForApp() for the response returned.
  */
 TEST_F(RadioHidlTest, supplyIccPukForApp) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
-  // 3GPP2 apps only
-  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
-    if (cardStatus.applications[i].appType == AppType::SIM ||
-        cardStatus.applications[i].appType == AppType::USIM ||
-        cardStatus.applications[i].appType == AppType::RUIM ||
-        cardStatus.applications[i].appType == AppType::CSIM) {
-      radio->supplyIccPukForApp(++serial, hidl_string("test1"),
-                                hidl_string("test2"),
-                                cardStatus.applications[i].aidPtr);
-      EXPECT_EQ(std::cv_status::no_timeout, wait());
-      EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-      EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-      EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+    // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+    // 3GPP2 apps only
+    for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+        if (cardStatus.applications[i].appType == AppType::SIM ||
+            cardStatus.applications[i].appType == AppType::USIM ||
+            cardStatus.applications[i].appType == AppType::RUIM ||
+            cardStatus.applications[i].appType == AppType::CSIM) {
+            radio->supplyIccPukForApp(serial, hidl_string("test1"), hidl_string("test2"),
+                                      cardStatus.applications[i].aidPtr);
+            EXPECT_EQ(std::cv_status::no_timeout, wait());
+            EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+            EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+            EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+        }
     }
-  }
 }
 
 /*
  * Test IRadio.supplyIccPin2ForApp() for the response returned.
  */
 TEST_F(RadioHidlTest, supplyIccPin2ForApp) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
-  // 3GPP2 apps only
-  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
-    if (cardStatus.applications[i].appType == AppType::SIM ||
-        cardStatus.applications[i].appType == AppType::USIM ||
-        cardStatus.applications[i].appType == AppType::RUIM ||
-        cardStatus.applications[i].appType == AppType::CSIM) {
-      radio->supplyIccPin2ForApp(++serial, hidl_string("test1"),
-                                 cardStatus.applications[i].aidPtr);
-      EXPECT_EQ(std::cv_status::no_timeout, wait());
-      EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-      EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-      EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+    // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+    // 3GPP2 apps only
+    for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+        if (cardStatus.applications[i].appType == AppType::SIM ||
+            cardStatus.applications[i].appType == AppType::USIM ||
+            cardStatus.applications[i].appType == AppType::RUIM ||
+            cardStatus.applications[i].appType == AppType::CSIM) {
+            radio->supplyIccPin2ForApp(serial, hidl_string("test1"),
+                                       cardStatus.applications[i].aidPtr);
+            EXPECT_EQ(std::cv_status::no_timeout, wait());
+            EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+            EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+            EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+        }
     }
-  }
 }
 
 /*
  * Test IRadio.supplyIccPuk2ForApp() for the response returned.
  */
 TEST_F(RadioHidlTest, supplyIccPuk2ForApp) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
-  // 3GPP2 apps only
-  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
-    if (cardStatus.applications[i].appType == AppType::SIM ||
-        cardStatus.applications[i].appType == AppType::USIM ||
-        cardStatus.applications[i].appType == AppType::RUIM ||
-        cardStatus.applications[i].appType == AppType::CSIM) {
-      radio->supplyIccPuk2ForApp(++serial, hidl_string("test1"),
-                                 hidl_string("test2"),
-                                 cardStatus.applications[i].aidPtr);
-      EXPECT_EQ(std::cv_status::no_timeout, wait());
-      EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-      EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-      EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+    // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+    // 3GPP2 apps only
+    for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+        if (cardStatus.applications[i].appType == AppType::SIM ||
+            cardStatus.applications[i].appType == AppType::USIM ||
+            cardStatus.applications[i].appType == AppType::RUIM ||
+            cardStatus.applications[i].appType == AppType::CSIM) {
+            radio->supplyIccPuk2ForApp(serial, hidl_string("test1"), hidl_string("test2"),
+                                       cardStatus.applications[i].aidPtr);
+            EXPECT_EQ(std::cv_status::no_timeout, wait());
+            EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+            EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+            EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+        }
     }
-  }
 }
 
 /*
  * Test IRadio.changeIccPinForApp() for the response returned.
  */
 TEST_F(RadioHidlTest, changeIccPinForApp) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
-  // 3GPP2 apps only
-  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
-    if (cardStatus.applications[i].appType == AppType::SIM ||
-        cardStatus.applications[i].appType == AppType::USIM ||
-        cardStatus.applications[i].appType == AppType::RUIM ||
-        cardStatus.applications[i].appType == AppType::CSIM) {
-      radio->changeIccPinForApp(++serial, hidl_string("test1"),
-                                hidl_string("test2"),
-                                cardStatus.applications[i].aidPtr);
-      EXPECT_EQ(std::cv_status::no_timeout, wait());
-      EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-      EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-      EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+    // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+    // 3GPP2 apps only
+    for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+        if (cardStatus.applications[i].appType == AppType::SIM ||
+            cardStatus.applications[i].appType == AppType::USIM ||
+            cardStatus.applications[i].appType == AppType::RUIM ||
+            cardStatus.applications[i].appType == AppType::CSIM) {
+            radio->changeIccPinForApp(serial, hidl_string("test1"), hidl_string("test2"),
+                                      cardStatus.applications[i].aidPtr);
+            EXPECT_EQ(std::cv_status::no_timeout, wait());
+            EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+            EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+            EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+        }
     }
-  }
 }
 
 /*
  * Test IRadio.changeIccPin2ForApp() for the response returned.
  */
 TEST_F(RadioHidlTest, changeIccPin2ForApp) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
-  // 3GPP2 apps only
-  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
-    if (cardStatus.applications[i].appType == AppType::SIM ||
-        cardStatus.applications[i].appType == AppType::USIM ||
-        cardStatus.applications[i].appType == AppType::RUIM ||
-        cardStatus.applications[i].appType == AppType::CSIM) {
-      radio->changeIccPin2ForApp(++serial, hidl_string("test1"),
-                                 hidl_string("test2"),
-                                 cardStatus.applications[i].aidPtr);
-      EXPECT_EQ(std::cv_status::no_timeout, wait());
-      EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-      EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-      EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+    // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+    // 3GPP2 apps only
+    for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+        if (cardStatus.applications[i].appType == AppType::SIM ||
+            cardStatus.applications[i].appType == AppType::USIM ||
+            cardStatus.applications[i].appType == AppType::RUIM ||
+            cardStatus.applications[i].appType == AppType::CSIM) {
+            radio->changeIccPin2ForApp(serial, hidl_string("test1"), hidl_string("test2"),
+                                       cardStatus.applications[i].aidPtr);
+            EXPECT_EQ(std::cv_status::no_timeout, wait());
+            EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+            EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+            EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
+        }
     }
-  }
 }
 
 /*
  * Test IRadio.getImsiForApp() for the response returned.
  */
 TEST_F(RadioHidlTest, getImsiForApp) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  // Check success returned while getting imsi for 3GPP and 3GPP2 apps only
-  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
-    if (cardStatus.applications[i].appType == AppType::SIM ||
-        cardStatus.applications[i].appType == AppType::USIM ||
-        cardStatus.applications[i].appType == AppType::RUIM ||
-        cardStatus.applications[i].appType == AppType::CSIM) {
-      radio->getImsiForApp(++serial, cardStatus.applications[i].aidPtr);
-      EXPECT_EQ(std::cv_status::no_timeout, wait());
-      EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-      EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-      EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+    // Check success returned while getting imsi for 3GPP and 3GPP2 apps only
+    for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+        if (cardStatus.applications[i].appType == AppType::SIM ||
+            cardStatus.applications[i].appType == AppType::USIM ||
+            cardStatus.applications[i].appType == AppType::RUIM ||
+            cardStatus.applications[i].appType == AppType::CSIM) {
+            radio->getImsiForApp(serial, cardStatus.applications[i].aidPtr);
+            EXPECT_EQ(std::cv_status::no_timeout, wait());
+            EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+            EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+            EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
 
-      // IMSI (MCC+MNC+MSIN) is at least 6 digits, but not more than 15
-      if (radioRsp->rspInfo.error == RadioError::NONE) {
-        EXPECT_NE(radioRsp->imsi, hidl_string());
-        EXPECT_GE((int)(radioRsp->imsi).size(), 6);
-        EXPECT_LE((int)(radioRsp->imsi).size(), 15);
-      }
+            // IMSI (MCC+MNC+MSIN) is at least 6 digits, but not more than 15
+            if (radioRsp->rspInfo.error == RadioError::NONE) {
+                EXPECT_NE(radioRsp->imsi, hidl_string());
+                EXPECT_GE((int)(radioRsp->imsi).size(), 6);
+                EXPECT_LE((int)(radioRsp->imsi).size(), 15);
+            }
+        }
     }
-  }
 }
 
 /*
  * Test IRadio.iccIOForApp() for the response returned.
  */
 TEST_F(RadioHidlTest, iccIOForApp) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
-    IccIo iccIo;
-    iccIo.command = 0xc0;
-    iccIo.fileId = 0x6f11;
-    iccIo.path = hidl_string("3F007FFF");
-    iccIo.p1 = 0;
-    iccIo.p2 = 0;
-    iccIo.p3 = 0;
-    iccIo.data = hidl_string();
-    iccIo.pin2 = hidl_string();
-    iccIo.aid = cardStatus.applications[i].aidPtr;
+    for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+        IccIo iccIo;
+        iccIo.command = 0xc0;
+        iccIo.fileId = 0x6f11;
+        iccIo.path = hidl_string("3F007FFF");
+        iccIo.p1 = 0;
+        iccIo.p2 = 0;
+        iccIo.p3 = 0;
+        iccIo.data = hidl_string();
+        iccIo.pin2 = hidl_string();
+        iccIo.aid = cardStatus.applications[i].aidPtr;
 
-    radio->iccIOForApp(++serial, iccIo);
-    EXPECT_EQ(std::cv_status::no_timeout, wait());
-    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-  }
+        radio->iccIOForApp(serial, iccIo);
+        EXPECT_EQ(std::cv_status::no_timeout, wait());
+        EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+        EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    }
 }
 
 /*
  * Test IRadio.iccTransmitApduBasicChannel() for the response returned.
  */
 TEST_F(RadioHidlTest, iccTransmitApduBasicChannel) {
-  int serial = 1;
-  SimApdu msg;
-  memset(&msg, 0, sizeof(msg));
-  msg.data = hidl_string();
+    int serial = GetRandomSerialNumber();
+    SimApdu msg;
+    memset(&msg, 0, sizeof(msg));
+    msg.data = hidl_string();
 
-  radio->iccTransmitApduBasicChannel(serial, msg);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->iccTransmitApduBasicChannel(serial, msg);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  // TODO(sanketpadawe): Add test for error code
+    // TODO(sanketpadawe): Add test for error code
 }
 
 /*
  * Test IRadio.iccOpenLogicalChannel() for the response returned.
  */
 TEST_F(RadioHidlTest, iccOpenLogicalChannel) {
-  int serial = 1;
-  int p2 = 0x04;
-  // Specified in ISO 7816-4 clause 7.1.1 0x04 means that FCP template is
-  // requested.
-  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
-      radio->iccOpenLogicalChannel(++serial, cardStatus.applications[i].aidPtr,
-                                   p2);
-      EXPECT_EQ(std::cv_status::no_timeout, wait());
-      EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-      EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  }
+    int serial = GetRandomSerialNumber();
+    int p2 = 0x04;
+    // Specified in ISO 7816-4 clause 7.1.1 0x04 means that FCP template is requested.
+    for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+        radio->iccOpenLogicalChannel(serial, cardStatus.applications[i].aidPtr, p2);
+        EXPECT_EQ(std::cv_status::no_timeout, wait());
+        EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+        EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    }
 }
 
 /*
  * Test IRadio.iccCloseLogicalChannel() for the response returned.
  */
 TEST_F(RadioHidlTest, iccCloseLogicalChannel) {
-  int serial = 1;
-  // Try closing invalid channel and check INVALID_ARGUMENTS returned as error
-  radio->iccCloseLogicalChannel(serial, 0);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    int serial = GetRandomSerialNumber();
+    // Try closing invalid channel and check INVALID_ARGUMENTS returned as error
+    radio->iccCloseLogicalChannel(serial, 0);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
+    EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
 }
 
 /*
  * Test IRadio.iccTransmitApduLogicalChannel() for the response returned.
  */
 TEST_F(RadioHidlTest, iccTransmitApduLogicalChannel) {
-  SimApdu msg;
-  memset(&msg, 0, sizeof(msg));
-  msg.data = hidl_string();
+    int serial = GetRandomSerialNumber();
+    SimApdu msg;
+    memset(&msg, 0, sizeof(msg));
+    msg.data = hidl_string();
 
-  radio->iccTransmitApduLogicalChannel(1, msg);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(1, radioRsp->rspInfo.serial);
+    radio->iccTransmitApduLogicalChannel(serial, msg);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  // TODO(sanketpadawe): Add test for error code
+    // TODO(sanketpadawe): Add test for error code
 }
 
 /*
  * Test IRadio.requestIccSimAuthentication() for the response returned.
  */
 TEST_F(RadioHidlTest, requestIccSimAuthentication) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  // Pass wrong challenge string and check RadioError::INVALID_ARGUMENTS
-  // returned as error.
-  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
-    radio->requestIccSimAuthentication(++serial, 0, hidl_string("test"),
-                                       cardStatus.applications[i].aidPtr);
-    EXPECT_EQ(std::cv_status::no_timeout, wait());
-    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-    EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
-  }
+    // Pass wrong challenge string and check RadioError::INVALID_ARGUMENTS
+    // returned as error.
+    for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+        radio->requestIccSimAuthentication(serial, 0, hidl_string("test"),
+                                           cardStatus.applications[i].aidPtr);
+        EXPECT_EQ(std::cv_status::no_timeout, wait());
+        EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+        EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+        EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
+    }
 }
 
 /*
  * Test IRadio.supplyNetworkDepersonalization() for the response returned.
  */
 TEST_F(RadioHidlTest, supplyNetworkDepersonalization) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->supplyNetworkDepersonalization(serial, hidl_string("test"));
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->supplyNetworkDepersonalization(serial, hidl_string("test"));
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
-                  radioRsp->rspInfo.error == RadioError::NO_MEMORY ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_SIM_STATE ||
-                  radioRsp->rspInfo.error == RadioError::PASSWORD_INCORRECT ||
-                  radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                    radioRsp->rspInfo.error == RadioError::NO_MEMORY ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_SIM_STATE ||
+                    radioRsp->rspInfo.error == RadioError::PASSWORD_INCORRECT ||
+                    radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+    }
 }
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_ims.cpp b/radio/1.0/vts/functional/radio_hidl_hal_ims.cpp
index ddf6b7e..ec99d42 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_ims.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_ims.cpp
@@ -22,178 +22,174 @@
  * Test IRadio.getClir() for the response returned.
  */
 TEST_F(RadioHidlTest, getClir) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  radio->getClir(++serial);
+    radio->getClir(serial);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.setClir() for the response returned.
  */
 TEST_F(RadioHidlTest, setClir) {
-  int serial = 0;
-  int32_t status = 1;
+    int serial = GetRandomSerialNumber();
+    int32_t status = 1;
 
-  radio->setClir(++serial, status);
+    radio->setClir(serial, status);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+    }
 }
 
 /*
  * Test IRadio.getFacilityLockForApp() for the response returned.
  */
 TEST_F(RadioHidlTest, getFacilityLockForApp) {
-  int serial = 0;
-  std::string facility = "";
-  std::string password = "";
-  int32_t serviceClass = 1;
-  std::string appId = "";
+    int serial = GetRandomSerialNumber();
+    std::string facility = "";
+    std::string password = "";
+    int32_t serviceClass = 1;
+    std::string appId = "";
 
-  radio->getFacilityLockForApp(++serial, facility, password, serviceClass,
-                               appId);
+    radio->getFacilityLockForApp(serial, facility, password, serviceClass, appId);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.setFacilityLockForApp() for the response returned.
  */
 TEST_F(RadioHidlTest, setFacilityLockForApp) {
-  int serial = 0;
-  std::string facility = "";
-  bool lockState = false;
-  std::string password = "";
-  int32_t serviceClass = 1;
-  std::string appId = "";
+    int serial = GetRandomSerialNumber();
+    std::string facility = "";
+    bool lockState = false;
+    std::string password = "";
+    int32_t serviceClass = 1;
+    std::string appId = "";
 
-  radio->setFacilityLockForApp(++serial, facility, lockState, password,
-                               serviceClass, appId);
+    radio->setFacilityLockForApp(serial, facility, lockState, password, serviceClass, appId);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.setBarringPassword() for the response returned.
  */
 TEST_F(RadioHidlTest, setBarringPassword) {
-  int serial = 0;
-  std::string facility = "";
-  std::string oldPassword = "";
-  std::string newPassword = "";
+    int serial = GetRandomSerialNumber();
+    std::string facility = "";
+    std::string oldPassword = "";
+    std::string newPassword = "";
 
-  radio->setBarringPassword(++serial, facility, oldPassword, newPassword);
+    radio->setBarringPassword(serial, facility, oldPassword, newPassword);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
-                  radioRsp->rspInfo.error == RadioError::FDN_CHECK_FAILURE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                    radioRsp->rspInfo.error == RadioError::FDN_CHECK_FAILURE);
+    }
 }
 
 /*
  * Test IRadio.getClip() for the response returned.
  */
 TEST_F(RadioHidlTest, getClip) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  radio->getClip(++serial);
+    radio->getClip(serial);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.setSuppServiceNotifications() for the response returned.
  */
 TEST_F(RadioHidlTest, setSuppServiceNotifications) {
-  int serial = 0;
-  bool enable = false;
+    int serial = GetRandomSerialNumber();
+    bool enable = false;
 
-  radio->setSuppServiceNotifications(++serial, enable);
+    radio->setSuppServiceNotifications(serial, enable);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+    }
 }
 
 /*
  * Test IRadio.requestIsimAuthentication() for the response returned.
  */
 TEST_F(RadioHidlTest, requestIsimAuthentication) {
-  int serial = 0;
-  std::string challenge = "";
+    int serial = GetRandomSerialNumber();
+    std::string challenge = "";
 
-  radio->requestIsimAuthentication(++serial, challenge);
+    radio->requestIsimAuthentication(serial, challenge);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError());
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError());
+    }
 }
 
 /*
  * Test IRadio.getImsRegistrationState() for the response returned.
  */
 TEST_F(RadioHidlTest, getImsRegistrationState) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  radio->getImsRegistrationState(++serial);
+    radio->getImsRegistrationState(serial);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+    }
 }
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_misc.cpp b/radio/1.0/vts/functional/radio_hidl_hal_misc.cpp
index eac35f7..29cb912 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_misc.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_misc.cpp
@@ -20,818 +20,809 @@
  * Test IRadio.getSignalStrength() for the response returned.
  */
 TEST_F(RadioHidlTest, getSignalStrength) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getSignalStrength(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getSignalStrength(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getVoiceRegistrationState() for the response returned.
  */
 TEST_F(RadioHidlTest, getVoiceRegistrationState) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getVoiceRegistrationState(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getVoiceRegistrationState(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getOperator() for the response returned.
  */
 TEST_F(RadioHidlTest, getOperator) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getOperator(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getOperator(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setRadioPower() for the response returned.
  */
 TEST_F(RadioHidlTest, setRadioPower) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setRadioPower(++serial, 0);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setRadioPower(serial, 0);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getNetworkSelectionMode() for the response returned.
  */
 TEST_F(RadioHidlTest, getNetworkSelectionMode) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getNetworkSelectionMode(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getNetworkSelectionMode(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setNetworkSelectionModeAutomatic() for the response returned.
  */
 TEST_F(RadioHidlTest, setNetworkSelectionModeAutomatic) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setNetworkSelectionModeAutomatic(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setNetworkSelectionModeAutomatic(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::OPERATION_NOT_ALLOWED);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::OPERATION_NOT_ALLOWED);
+    }
 }
 
 /*
  * Test IRadio.setNetworkSelectionModeManual() for the response returned.
  */
 TEST_F(RadioHidlTest, setNetworkSelectionModeManual) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setNetworkSelectionModeManual(++serial, "123456");
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setNetworkSelectionModeManual(serial, "123456");
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+    }
 }
 
 /*
  * Test IRadio.getAvailableNetworks() for the response returned.
  */
 TEST_F(RadioHidlTest, getAvailableNetworks) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getAvailableNetworks(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-  ASSERT_TRUE(radioRsp->rspInfo.type == RadioResponseType::SOLICITED ||
-              radioRsp->rspInfo.type == RadioResponseType::SOLICITED_ACK_EXP);
+    radio->getAvailableNetworks(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    ASSERT_TRUE(radioRsp->rspInfo.type == RadioResponseType::SOLICITED ||
+                radioRsp->rspInfo.type == RadioResponseType::SOLICITED_ACK_EXP);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(
-          CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
-          radioRsp->rspInfo.error == RadioError::DEVICE_IN_USE ||
-          radioRsp->rspInfo.error == RadioError::CANCELLED ||
-          radioRsp->rspInfo.error == RadioError::OPERATION_NOT_ALLOWED ||
-          radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::DEVICE_IN_USE ||
+                    radioRsp->rspInfo.error == RadioError::CANCELLED ||
+                    radioRsp->rspInfo.error == RadioError::OPERATION_NOT_ALLOWED ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.getBasebandVersion() for the response returned.
  */
 TEST_F(RadioHidlTest, getBasebandVersion) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getBasebandVersion(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getBasebandVersion(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setBandMode() for the response returned.
  */
 TEST_F(RadioHidlTest, setBandMode) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setBandMode(++serial, RadioBandMode::BAND_MODE_USA);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setBandMode(serial, RadioBandMode::BAND_MODE_USA);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getAvailableBandModes() for the response returned.
  */
 TEST_F(RadioHidlTest, getAvailableBandModes) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getAvailableBandModes(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getAvailableBandModes(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setPreferredNetworkType() for the response returned.
  */
 TEST_F(RadioHidlTest, setPreferredNetworkType) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setPreferredNetworkType(++serial, PreferredNetworkType::GSM_ONLY);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setPreferredNetworkType(serial, PreferredNetworkType::GSM_ONLY);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getPreferredNetworkType() for the response returned.
  */
 TEST_F(RadioHidlTest, getPreferredNetworkType) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getPreferredNetworkType(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getPreferredNetworkType(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getNeighboringCids() for the response returned.
  */
 TEST_F(RadioHidlTest, getNeighboringCids) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getNeighboringCids(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getNeighboringCids(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setLocationUpdates() for the response returned.
  */
 TEST_F(RadioHidlTest, setLocationUpdates) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setLocationUpdates(++serial, true);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setLocationUpdates(serial, true);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setCdmaRoamingPreference() for the response returned.
  */
 TEST_F(RadioHidlTest, setCdmaRoamingPreference) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setCdmaRoamingPreference(++serial, CdmaRoamingType::HOME_NETWORK);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setCdmaRoamingPreference(serial, CdmaRoamingType::HOME_NETWORK);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getCdmaRoamingPreference() for the response returned.
  */
 TEST_F(RadioHidlTest, getCdmaRoamingPreference) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getCdmaRoamingPreference(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getCdmaRoamingPreference(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.getTTYMode() for the response returned.
  */
 TEST_F(RadioHidlTest, getTTYMode) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getTTYMode(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getTTYMode(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setTTYMode() for the response returned.
  */
 TEST_F(RadioHidlTest, setTTYMode) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setTTYMode(++serial, TtyMode::OFF);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setTTYMode(serial, TtyMode::OFF);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setPreferredVoicePrivacy() for the response returned.
  */
 TEST_F(RadioHidlTest, setPreferredVoicePrivacy) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setPreferredVoicePrivacy(++serial, true);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setPreferredVoicePrivacy(serial, true);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getPreferredVoicePrivacy() for the response returned.
  */
 TEST_F(RadioHidlTest, getPreferredVoicePrivacy) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getPreferredVoicePrivacy(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getPreferredVoicePrivacy(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getCDMASubscription() for the response returned.
  */
 TEST_F(RadioHidlTest, getCDMASubscription) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getCDMASubscription(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getCDMASubscription(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getDeviceIdentity() for the response returned.
  */
 TEST_F(RadioHidlTest, getDeviceIdentity) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getDeviceIdentity(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getDeviceIdentity(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.exitEmergencyCallbackMode() for the response returned.
  */
 TEST_F(RadioHidlTest, exitEmergencyCallbackMode) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->exitEmergencyCallbackMode(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->exitEmergencyCallbackMode(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getCdmaSubscriptionSource() for the response returned.
  */
 TEST_F(RadioHidlTest, getCdmaSubscriptionSource) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getCdmaSubscriptionSource(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getCdmaSubscriptionSource(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setCdmaSubscriptionSource() for the response returned.
  */
 TEST_F(RadioHidlTest, setCdmaSubscriptionSource) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setCdmaSubscriptionSource(++serial, CdmaSubscriptionSource::RUIM_SIM);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setCdmaSubscriptionSource(serial, CdmaSubscriptionSource::RUIM_SIM);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::SIM_ABSENT ||
-                radioRsp->rspInfo.error ==
-                    RadioError::SUBSCRIPTION_NOT_AVAILABLE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::SIM_ABSENT ||
+                    radioRsp->rspInfo.error == RadioError::SUBSCRIPTION_NOT_AVAILABLE);
+    }
 }
 
 /*
  * Test IRadio.getVoiceRadioTechnology() for the response returned.
  */
 TEST_F(RadioHidlTest, getVoiceRadioTechnology) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getVoiceRadioTechnology(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getVoiceRadioTechnology(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getCellInfoList() for the response returned.
  */
 TEST_F(RadioHidlTest, getCellInfoList) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getCellInfoList(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getCellInfoList(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::NO_NETWORK_FOUND);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::NO_NETWORK_FOUND);
+    }
 }
 
 /*
  * Test IRadio.setCellInfoListRate() for the response returned.
  */
 TEST_F(RadioHidlTest, setCellInfoListRate) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  // TODO(sanketpadawe): RIL crashes with value of rate = 10
-  radio->setCellInfoListRate(++serial, 10);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    // TODO(sanketpadawe): RIL crashes with value of rate = 10
+    radio->setCellInfoListRate(serial, 10);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.nvReadItem() for the response returned.
  */
 TEST_F(RadioHidlTest, nvReadItem) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->nvReadItem(++serial, NvItem::LTE_BAND_ENABLE_25);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->nvReadItem(serial, NvItem::LTE_BAND_ENABLE_25);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.nvWriteItem() for the response returned.
  */
 TEST_F(RadioHidlTest, nvWriteItem) {
-  int serial = 1;
-  NvWriteItem item;
-  memset(&item, 0, sizeof(item));
-  item.value = hidl_string();
+    int serial = GetRandomSerialNumber();
+    NvWriteItem item;
+    memset(&item, 0, sizeof(item));
+    item.value = hidl_string();
 
-  radio->nvWriteItem(++serial, item);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->nvWriteItem(serial, item);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.nvWriteCdmaPrl() for the response returned.
  */
 TEST_F(RadioHidlTest, nvWriteCdmaPrl) {
-  int serial = 1;
-  std::vector<uint8_t> prl = {1, 2, 3, 4, 5};
+    int serial = GetRandomSerialNumber();
+    std::vector<uint8_t> prl = {1, 2, 3, 4, 5};
 
-  radio->nvWriteCdmaPrl(++serial, hidl_vec<uint8_t>(prl));
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->nvWriteCdmaPrl(serial, hidl_vec<uint8_t>(prl));
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.nvResetConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, nvResetConfig) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->nvResetConfig(++serial, ResetNvType::ERASE);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->nvResetConfig(++serial, ResetNvType::ERASE);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setUiccSubscription() for the response returned.
  */
 TEST_F(RadioHidlTest, setUiccSubscription) {
-  int serial = 1;
-  SelectUiccSub item;
-  memset(&item, 0, sizeof(item));
+    int serial = GetRandomSerialNumber();
+    SelectUiccSub item;
+    memset(&item, 0, sizeof(item));
 
-  radio->setUiccSubscription(++serial, item);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setUiccSubscription(serial, item);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error ==
-                      RadioError::SUBSCRIPTION_NOT_SUPPORTED ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::SUBSCRIPTION_NOT_SUPPORTED ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.getHardwareConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, getHardwareConfig) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getHardwareConfig(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getHardwareConfig(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.requestShutdown() for the response returned.
  */
 TEST_F(RadioHidlTest, requestShutdown) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->requestShutdown(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->requestShutdown(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getRadioCapability() for the response returned.
  */
 TEST_F(RadioHidlTest, getRadioCapability) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getRadioCapability(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getRadioCapability(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setRadioCapability() for the response returned.
  */
 TEST_F(RadioHidlTest, setRadioCapability) {
-  int serial = 1;
-  RadioCapability rc;
-  memset(&rc, 0, sizeof(rc));
-  rc.logicalModemUuid = hidl_string();
+    int serial = GetRandomSerialNumber();
+    RadioCapability rc;
+    memset(&rc, 0, sizeof(rc));
+    rc.logicalModemUuid = hidl_string();
 
-  radio->setRadioCapability(++serial, rc);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setRadioCapability(serial, rc);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+    }
 }
 
 /*
  * Test IRadio.startLceService() for the response returned.
  */
 TEST_F(RadioHidlTest, startLceService) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->startLceService(++serial, 5, true);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->startLceService(serial, 5, true);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE ||
-                  radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED ||
-                  radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE ||
+                    radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED ||
+                    radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+    }
 }
 
 /*
  * Test IRadio.stopLceService() for the response returned.
  */
 TEST_F(RadioHidlTest, stopLceService) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->stopLceService(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->stopLceService(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
-                radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED);
+    }
 }
 
 /*
  * Test IRadio.pullLceData() for the response returned.
  */
 TEST_F(RadioHidlTest, pullLceData) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->pullLceData(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->pullLceData(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE ||
-                  CheckOEMError());
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE || CheckOEMError());
+    }
 }
 
 /*
  * Test IRadio.getModemActivityInfo() for the response returned.
  */
 TEST_F(RadioHidlTest, getModemActivityInfo) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getModemActivityInfo(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getModemActivityInfo(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.setAllowedCarriers() for the response returned.
  */
 TEST_F(RadioHidlTest, setAllowedCarriers) {
-  int serial = 1;
-  CarrierRestrictions carriers;
+    int serial = GetRandomSerialNumber();
+    CarrierRestrictions carriers;
+    memset(&carriers, 0, sizeof(carriers));
+    carriers.allowedCarriers.resize(1);
+    carriers.excludedCarriers.resize(0);
+    carriers.allowedCarriers[0].mcc = hidl_string();
+    carriers.allowedCarriers[0].mnc = hidl_string();
+    carriers.allowedCarriers[0].matchType = CarrierMatchType::ALL;
+    carriers.allowedCarriers[0].matchData = hidl_string();
 
-  /* Carrier restriction with one carrier */
-  memset(&carriers, 0, sizeof(carriers));
-  carriers.allowedCarriers.resize(1);
-  carriers.excludedCarriers.resize(0);
-  carriers.allowedCarriers[0].mcc = hidl_string();
-  carriers.allowedCarriers[0].mnc = hidl_string();
-  carriers.allowedCarriers[0].matchType = CarrierMatchType::ALL;
-  carriers.allowedCarriers[0].matchData = hidl_string();
+    radio->setAllowedCarriers(serial, false, carriers);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  radio->setAllowedCarriers(++serial, false, carriers);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    /* Reset back to no carrier restriction */
+    memset(&carriers, 0, sizeof(carriers));
+    carriers.allowedCarriers.resize(0);
+    carriers.excludedCarriers.resize(0);
 
-  /* Reset back to no carrier restriction */
-  memset(&carriers, 0, sizeof(carriers));
-  carriers.allowedCarriers.resize(0);
-  carriers.excludedCarriers.resize(0);
+    radio->setAllowedCarriers(++serial, true, carriers);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  radio->setAllowedCarriers(++serial, true, carriers);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
-
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getAllowedCarriers() for the response returned.
  */
 TEST_F(RadioHidlTest, getAllowedCarriers) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getAllowedCarriers(++serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getAllowedCarriers(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.sendDeviceState() for the response returned.
  */
 TEST_F(RadioHidlTest, sendDeviceState) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->sendDeviceState(++serial, DeviceStateType::POWER_SAVE_MODE, true);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->sendDeviceState(serial, DeviceStateType::POWER_SAVE_MODE, true);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 }
 
 /*
  * Test IRadio.setIndicationFilter() for the response returned.
  */
 TEST_F(RadioHidlTest, setIndicationFilter) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setIndicationFilter(++serial, 1);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setIndicationFilter(serial, 1);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 }
 
 /*
  * Test IRadio.setSimCardPower() for the response returned.
  */
 TEST_F(RadioHidlTest, setSimCardPower) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setSimCardPower(++serial, true);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setSimCardPower(serial, true);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE
-        || radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
-  }
-}
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
+    }
+}
\ No newline at end of file
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_sms.cpp b/radio/1.0/vts/functional/radio_hidl_hal_sms.cpp
index b8a50c0..698cf26 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_sms.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_sms.cpp
@@ -22,417 +22,412 @@
  * Test IRadio.sendSms() for the response returned.
  */
 TEST_F(RadioHidlTest, sendSms) {
-  int serial = 0;
-  GsmSmsMessage msg;
-  msg.smscPdu = "";
-  msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
+    int serial = GetRandomSerialNumber();
+    GsmSmsMessage msg;
+    msg.smscPdu = "";
+    msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
 
-  radio->sendSms(++serial, msg);
+    radio->sendSms(serial, msg);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-      EXPECT_EQ(0, radioRsp->sendSmsResult.errorCode);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+        EXPECT_EQ(0, radioRsp->sendSmsResult.errorCode);
+    }
 }
 
 /*
  * Test IRadio.sendSMSExpectMore() for the response returned.
  */
 TEST_F(RadioHidlTest, sendSMSExpectMore) {
-  int serial = 0;
-  GsmSmsMessage msg;
-  msg.smscPdu = "";
-  msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
+    int serial = GetRandomSerialNumber();
+    GsmSmsMessage msg;
+    msg.smscPdu = "";
+    msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
 
-  radio->sendSMSExpectMore(++serial, msg);
+    radio->sendSMSExpectMore(serial, msg);
 
-  // TODO(shuoq): add more test for this API when inserted sim card is
-  // considered
+    // TODO(shuoq): add more test for this API when inserted sim card is
+    // considered
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+    }
 }
 
 /*
  * Test IRadio.acknowledgeLastIncomingGsmSms() for the response returned.
  */
 TEST_F(RadioHidlTest, acknowledgeLastIncomingGsmSms) {
-  int serial = 0;
-  bool success = true;
+    int serial = GetRandomSerialNumber();
+    bool success = true;
 
-  radio->acknowledgeLastIncomingGsmSms(
-      ++serial, success, SmsAcknowledgeFailCause::MEMORY_CAPACITY_EXCEEDED);
+    radio->acknowledgeLastIncomingGsmSms(serial, success,
+                                         SmsAcknowledgeFailCause::MEMORY_CAPACITY_EXCEEDED);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+    }
 }
 
 /*
  * Test IRadio.acknowledgeIncomingGsmSmsWithPdu() for the response returned.
  */
 TEST_F(RadioHidlTest, acknowledgeIncomingGsmSmsWithPdu) {
-  int serial = 0;
-  bool success = true;
-  std::string ackPdu = "";
+    int serial = GetRandomSerialNumber();
+    bool success = true;
+    std::string ackPdu = "";
 
-  radio->acknowledgeIncomingGsmSmsWithPdu(++serial, success, ackPdu);
+    radio->acknowledgeIncomingGsmSmsWithPdu(serial, success, ackPdu);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    // TODO(shuoq): Will add error check when we know the expected error from QC
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        // TODO(shuoq): Will add error check when we know the expected error from QC
+    }
 }
 
 /*
  * Test IRadio.sendCdmaSms() for the response returned.
  */
 TEST_F(RadioHidlTest, sendCdmaSms) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  // Create a CdmaSmsAddress
-  CdmaSmsAddress cdmaSmsAddress;
-  cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
-  cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
-  cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
-  cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
-  cdmaSmsAddress.digits =
-      (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
+    // Create a CdmaSmsAddress
+    CdmaSmsAddress cdmaSmsAddress;
+    cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
+    cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
+    cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
+    cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
+    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
 
-  // Create a CdmaSmsSubAddress
-  CdmaSmsSubaddress cdmaSmsSubaddress;
-  cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
-  cdmaSmsSubaddress.odd = false;
-  cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
+    // Create a CdmaSmsSubAddress
+    CdmaSmsSubaddress cdmaSmsSubaddress;
+    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
+    cdmaSmsSubaddress.odd = false;
+    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
 
-  // Create a CdmaSmsMessage
-  android::hardware::radio::V1_0::CdmaSmsMessage cdmaSmsMessage;
-  cdmaSmsMessage.teleserviceId = 4098;
-  cdmaSmsMessage.isServicePresent = false;
-  cdmaSmsMessage.serviceCategory = 0;
-  cdmaSmsMessage.address = cdmaSmsAddress;
-  cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
-  cdmaSmsMessage.bearerData = (std::vector<uint8_t>){
-      15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
+    // Create a CdmaSmsMessage
+    android::hardware::radio::V1_0::CdmaSmsMessage cdmaSmsMessage;
+    cdmaSmsMessage.teleserviceId = 4098;
+    cdmaSmsMessage.isServicePresent = false;
+    cdmaSmsMessage.serviceCategory = 0;
+    cdmaSmsMessage.address = cdmaSmsAddress;
+    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
+    cdmaSmsMessage.bearerData =
+        (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
 
-  radio->sendCdmaSms(++serial, cdmaSmsMessage);
+    radio->sendCdmaSms(serial, cdmaSmsMessage);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+    }
 }
 
 /*
  * Test IRadio.acknowledgeLastIncomingCdmaSms() for the response returned.
  */
 TEST_F(RadioHidlTest, acknowledgeLastIncomingCdmaSms) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  // Create a CdmaSmsAck
-  CdmaSmsAck cdmaSmsAck;
-  cdmaSmsAck.errorClass = CdmaSmsErrorClass::NO_ERROR;
-  cdmaSmsAck.smsCauseCode = 1;
+    // Create a CdmaSmsAck
+    CdmaSmsAck cdmaSmsAck;
+    cdmaSmsAck.errorClass = CdmaSmsErrorClass::NO_ERROR;
+    cdmaSmsAck.smsCauseCode = 1;
 
-  radio->acknowledgeLastIncomingCdmaSms(++serial, cdmaSmsAck);
+    radio->acknowledgeLastIncomingCdmaSms(serial, cdmaSmsAck);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::NO_SMS_TO_ACK);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::NO_SMS_TO_ACK);
+    }
 }
 
 /*
  * Test IRadio.sendImsSms() for the response returned.
  */
 TEST_F(RadioHidlTest, sendImsSms) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  // Create a CdmaSmsAddress
-  CdmaSmsAddress cdmaSmsAddress;
-  cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
-  cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
-  cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
-  cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
-  cdmaSmsAddress.digits =
-      (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
+    // Create a CdmaSmsAddress
+    CdmaSmsAddress cdmaSmsAddress;
+    cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
+    cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
+    cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
+    cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
+    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
 
-  // Create a CdmaSmsSubAddress
-  CdmaSmsSubaddress cdmaSmsSubaddress;
-  cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
-  cdmaSmsSubaddress.odd = false;
-  cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
+    // Create a CdmaSmsSubAddress
+    CdmaSmsSubaddress cdmaSmsSubaddress;
+    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
+    cdmaSmsSubaddress.odd = false;
+    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
 
-  // Create a CdmaSmsMessage
-  CdmaSmsMessage cdmaSmsMessage;
-  cdmaSmsMessage.teleserviceId = 4098;
-  cdmaSmsMessage.isServicePresent = false;
-  cdmaSmsMessage.serviceCategory = 0;
-  cdmaSmsMessage.address = cdmaSmsAddress;
-  cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
-  cdmaSmsMessage.bearerData = (std::vector<uint8_t>){
-      15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
+    // Create a CdmaSmsMessage
+    CdmaSmsMessage cdmaSmsMessage;
+    cdmaSmsMessage.teleserviceId = 4098;
+    cdmaSmsMessage.isServicePresent = false;
+    cdmaSmsMessage.serviceCategory = 0;
+    cdmaSmsMessage.address = cdmaSmsAddress;
+    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
+    cdmaSmsMessage.bearerData =
+        (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
 
-  // Creata an ImsSmsMessage
-  ImsSmsMessage msg;
-  msg.tech = RadioTechnologyFamily::THREE_GPP2;
-  msg.retry = false;
-  msg.messageRef = 0;
-  msg.cdmaMessage = (std::vector<CdmaSmsMessage>){cdmaSmsMessage};
-  msg.gsmMessage = (std::vector<GsmSmsMessage>){};
+    // Creata an ImsSmsMessage
+    ImsSmsMessage msg;
+    msg.tech = RadioTechnologyFamily::THREE_GPP2;
+    msg.retry = false;
+    msg.messageRef = 0;
+    msg.cdmaMessage = (std::vector<CdmaSmsMessage>){cdmaSmsMessage};
+    msg.gsmMessage = (std::vector<GsmSmsMessage>){};
 
-  radio->sendImsSms(serial, msg);
+    radio->sendImsSms(serial, msg);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 }
 
 /*
  * Test IRadio.getSmscAddress() for the response returned.
  */
 TEST_F(RadioHidlTest, getSmscAddress) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  radio->getSmscAddress(++serial);
+    radio->getSmscAddress(serial);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
+    }
 }
 
 /*
  * Test IRadio.setSmscAddress() for the response returned.
  */
 TEST_F(RadioHidlTest, setSmscAddress) {
-  int serial = 0;
-  hidl_string address = hidl_string("smscAddress");
+    int serial = GetRandomSerialNumber();
+    hidl_string address = hidl_string("smscAddress");
 
-  radio->setSmscAddress(++serial, address);
+    radio->setSmscAddress(serial, address);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_SMS_FORMAT);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_SMS_FORMAT);
+    }
 }
 
 /*
  * Test IRadio.writeSmsToSim() for the response returned.
  */
 TEST_F(RadioHidlTest, writeSmsToSim) {
-  int serial = 0;
-  SmsWriteArgs smsWriteArgs;
-  smsWriteArgs.status = SmsWriteArgsStatus::REC_UNREAD;
-  smsWriteArgs.smsc = "";
-  smsWriteArgs.pdu = "01000b916105770203f3000006d4f29c3e9b01";
+    int serial = GetRandomSerialNumber();
+    SmsWriteArgs smsWriteArgs;
+    smsWriteArgs.status = SmsWriteArgsStatus::REC_UNREAD;
+    smsWriteArgs.smsc = "";
+    smsWriteArgs.pdu = "01000b916105770203f3000006d4f29c3e9b01";
 
-  radio->writeSmsToSim(++serial, smsWriteArgs);
+    radio->writeSmsToSim(serial, smsWriteArgs);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
-                  radioRsp->rspInfo.error == RadioError::ENCODING_ERR ||
-                  radioRsp->rspInfo.error == RadioError::NO_RESOURCES ||
-                  radioRsp->rspInfo.error == RadioError::NETWORK_NOT_READY ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_SMSC_ADDRESS);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                    radioRsp->rspInfo.error == RadioError::ENCODING_ERR ||
+                    radioRsp->rspInfo.error == RadioError::NO_RESOURCES ||
+                    radioRsp->rspInfo.error == RadioError::NETWORK_NOT_READY ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_SMSC_ADDRESS);
+    }
 }
 
 /*
  * Test IRadio.deleteSmsOnSim() for the response returned.
  */
 TEST_F(RadioHidlTest, deleteSmsOnSim) {
-  int serial = 0;
-  int index = 1;
+    int serial = GetRandomSerialNumber();
+    int index = 1;
 
-  radio->deleteSmsOnSim(++serial, index);
+    radio->deleteSmsOnSim(serial, index);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
-                  radioRsp->rspInfo.error == RadioError::NO_SUCH_ENTRY);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                    radioRsp->rspInfo.error == RadioError::NO_SUCH_ENTRY);
+    }
 }
 
 /*
  * Test IRadio.writeSmsToRuim() for the response returned.
  */
 TEST_F(RadioHidlTest, writeSmsToRuim) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  // Create a CdmaSmsAddress
-  CdmaSmsAddress cdmaSmsAddress;
-  cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
-  cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
-  cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
-  cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
-  cdmaSmsAddress.digits =
-      (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
+    // Create a CdmaSmsAddress
+    CdmaSmsAddress cdmaSmsAddress;
+    cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
+    cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
+    cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
+    cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
+    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
 
-  // Create a CdmaSmsSubAddress
-  CdmaSmsSubaddress cdmaSmsSubaddress;
-  cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
-  cdmaSmsSubaddress.odd = false;
-  cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
+    // Create a CdmaSmsSubAddress
+    CdmaSmsSubaddress cdmaSmsSubaddress;
+    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
+    cdmaSmsSubaddress.odd = false;
+    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
 
-  // Create a CdmaSmsMessage
-  CdmaSmsMessage cdmaSmsMessage;
-  cdmaSmsMessage.teleserviceId = 4098;
-  cdmaSmsMessage.isServicePresent = false;
-  cdmaSmsMessage.serviceCategory = 0;
-  cdmaSmsMessage.address = cdmaSmsAddress;
-  cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
-  cdmaSmsMessage.bearerData = (std::vector<uint8_t>){
-      15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
+    // Create a CdmaSmsMessage
+    CdmaSmsMessage cdmaSmsMessage;
+    cdmaSmsMessage.teleserviceId = 4098;
+    cdmaSmsMessage.isServicePresent = false;
+    cdmaSmsMessage.serviceCategory = 0;
+    cdmaSmsMessage.address = cdmaSmsAddress;
+    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
+    cdmaSmsMessage.bearerData =
+        (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
 
-  // Create a CdmaSmsWriteArgs
-  CdmaSmsWriteArgs cdmaSmsWriteArgs;
-  cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
-  cdmaSmsWriteArgs.message = cdmaSmsMessage;
+    // Create a CdmaSmsWriteArgs
+    CdmaSmsWriteArgs cdmaSmsWriteArgs;
+    cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
+    cdmaSmsWriteArgs.message = cdmaSmsMessage;
 
-  radio->writeSmsToRuim(++serial, cdmaSmsWriteArgs);
+    radio->writeSmsToRuim(serial, cdmaSmsWriteArgs);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_SMS_FORMAT ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
-                  radioRsp->rspInfo.error == RadioError::NO_SUCH_ENTRY ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_SMSC_ADDRESS);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_SMS_FORMAT ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                    radioRsp->rspInfo.error == RadioError::NO_SUCH_ENTRY ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_SMSC_ADDRESS);
+    }
 }
 
 /*
  * Test IRadio.deleteSmsOnRuim() for the response returned.
  */
 TEST_F(RadioHidlTest, deleteSmsOnRuim) {
-  int serial = 0;
-  int index = 1;
+    int serial = GetRandomSerialNumber();
+    int index = 1;
 
-  // Create a CdmaSmsAddress
-  CdmaSmsAddress cdmaSmsAddress;
-  cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
-  cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
-  cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
-  cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
-  cdmaSmsAddress.digits =
-      (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
+    // Create a CdmaSmsAddress
+    CdmaSmsAddress cdmaSmsAddress;
+    cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
+    cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
+    cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
+    cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
+    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
 
-  // Create a CdmaSmsSubAddress
-  CdmaSmsSubaddress cdmaSmsSubaddress;
-  cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
-  cdmaSmsSubaddress.odd = false;
-  cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
+    // Create a CdmaSmsSubAddress
+    CdmaSmsSubaddress cdmaSmsSubaddress;
+    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
+    cdmaSmsSubaddress.odd = false;
+    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
 
-  // Create a CdmaSmsMessage
-  CdmaSmsMessage cdmaSmsMessage;
-  cdmaSmsMessage.teleserviceId = 4098;
-  cdmaSmsMessage.isServicePresent = false;
-  cdmaSmsMessage.serviceCategory = 0;
-  cdmaSmsMessage.address = cdmaSmsAddress;
-  cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
-  cdmaSmsMessage.bearerData = (std::vector<uint8_t>){
-      15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
+    // Create a CdmaSmsMessage
+    CdmaSmsMessage cdmaSmsMessage;
+    cdmaSmsMessage.teleserviceId = 4098;
+    cdmaSmsMessage.isServicePresent = false;
+    cdmaSmsMessage.serviceCategory = 0;
+    cdmaSmsMessage.address = cdmaSmsAddress;
+    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
+    cdmaSmsMessage.bearerData =
+        (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
 
-  // Create a CdmaSmsWriteArgs
-  CdmaSmsWriteArgs cdmaSmsWriteArgs;
-  cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
-  cdmaSmsWriteArgs.message = cdmaSmsMessage;
+    // Create a CdmaSmsWriteArgs
+    CdmaSmsWriteArgs cdmaSmsWriteArgs;
+    cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
+    cdmaSmsWriteArgs.message = cdmaSmsMessage;
 
-  radio->deleteSmsOnRuim(++serial, index);
+    radio->deleteSmsOnRuim(serial, index);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError());
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError());
+    }
 }
 
 /*
  * Test IRadio.reportSmsMemoryStatus() for the response returned.
  */
 TEST_F(RadioHidlTest, reportSmsMemoryStatus) {
-  int serial = 0;
-  bool available = true;
+    int serial = GetRandomSerialNumber();
+    bool available = true;
 
-  radio->reportSmsMemoryStatus(++serial, available);
+    radio->reportSmsMemoryStatus(serial, available);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_stk.cpp b/radio/1.0/vts/functional/radio_hidl_hal_stk.cpp
index 3858c90..0d86099 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_stk.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_stk.cpp
@@ -22,106 +22,111 @@
  * Test IRadio.sendEnvelope() for the response returned.
  */
 TEST_F(RadioHidlTest, sendEnvelope) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  // Test with sending empty string
-  std::string content = "";
+    // Test with sending empty string
+    std::string content = "";
 
-  radio->sendEnvelope(++serial, content);
+    radio->sendEnvelope(serial, content);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 
-  // Test with sending random string
-  content = "0";
+    // Test with sending random string
+    serial = GetRandomSerialNumber();
+    content = "0";
 
-  radio->sendEnvelope(++serial, content);
+    radio->sendEnvelope(serial, content);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 }
 
 /*
  * Test IRadio.sendTerminalResponseToSim() for the response returned.
  */
 TEST_F(RadioHidlTest, sendTerminalResponseToSim) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  // Test with sending empty string
-  std::string commandResponse = "";
+    // Test with sending empty string
+    std::string commandResponse = "";
 
-  radio->sendTerminalResponseToSim(++serial, commandResponse);
+    radio->sendTerminalResponseToSim(serial, commandResponse);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+    }
 
-  // Test with sending random string
-  commandResponse = "0";
+    serial = GetRandomSerialNumber();
 
-  radio->sendTerminalResponseToSim(++serial, commandResponse);
+    // Test with sending random string
+    commandResponse = "0";
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->sendTerminalResponseToSim(serial, commandResponse);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 }
 
 /*
  * Test IRadio.handleStkCallSetupRequestFromSim() for the response returned.
  */
 TEST_F(RadioHidlTest, handleStkCallSetupRequestFromSim) {
-  int serial = 0;
-  bool accept = false;
+    int serial = GetRandomSerialNumber();
+    bool accept = false;
 
-  radio->handleStkCallSetupRequestFromSim(++serial, accept);
+    radio->handleStkCallSetupRequestFromSim(serial, accept);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
-                  radioRsp->rspInfo.error == RadioError::NO_MEMORY ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 }
 
 /*
  * Test IRadio.reportStkServiceIsRunning() for the response returned.
  */
 TEST_F(RadioHidlTest, reportStkServiceIsRunning) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  radio->reportStkServiceIsRunning(++serial);
+    radio->reportStkServiceIsRunning(serial);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
@@ -129,31 +134,34 @@
  * string.
  */
 TEST_F(RadioHidlTest, sendEnvelopeWithStatus) {
-  int serial = 0;
+    int serial = GetRandomSerialNumber();
 
-  // Test with sending empty string
-  std::string contents = "";
+    // Test with sending empty string
+    std::string contents = "";
 
-  radio->sendEnvelopeWithStatus(++serial, contents);
+    radio->sendEnvelopeWithStatus(serial, contents);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 
-  // Test with sending random string
-  contents = "0";
+    // Test with sending random string
+    serial = GetRandomSerialNumber();
+    contents = "0";
 
-  radio->sendEnvelopeWithStatus(++serial, contents);
+    radio->sendEnvelopeWithStatus(serial, contents);
 
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
+    }
 }
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_test.cpp b/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
index 794c60f..b957c6e 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
@@ -17,46 +17,47 @@
 #include <radio_hidl_hal_utils.h>
 
 void RadioHidlTest::SetUp() {
-  radio = ::testing::VtsHalHidlTargetTestBase::getService<IRadio>(
-      hidl_string(RADIO_SERVICE_NAME));
-  ASSERT_NE(radio, nullptr);
+    radio =
+        ::testing::VtsHalHidlTargetTestBase::getService<IRadio>(hidl_string(RADIO_SERVICE_NAME));
+    ASSERT_NE(radio, nullptr);
 
-  radioRsp = new RadioResponse(*this);
-  ASSERT_NE(radioRsp, nullptr);
+    radioRsp = new RadioResponse(*this);
+    ASSERT_NE(radioRsp, nullptr);
 
-  count = 0;
+    count = 0;
 
-  radioInd = NULL;
-  radio->setResponseFunctions(radioRsp, radioInd);
+    radioInd = NULL;
+    radio->setResponseFunctions(radioRsp, radioInd);
 
-  radio->getIccCardStatus(1);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(1, radioRsp->rspInfo.serial);
-  EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+    int serial = GetRandomSerialNumber();
+    radio->getIccCardStatus(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
 }
 
 void RadioHidlTest::TearDown() {}
 
 void RadioHidlTest::notify() {
-  std::unique_lock<std::mutex> lock(mtx);
-  count++;
-  cv.notify_one();
+    std::unique_lock<std::mutex> lock(mtx);
+    count++;
+    cv.notify_one();
 }
 
 std::cv_status RadioHidlTest::wait() {
-  std::unique_lock<std::mutex> lock(mtx);
+    std::unique_lock<std::mutex> lock(mtx);
 
-  std::cv_status status = std::cv_status::no_timeout;
-  auto now = std::chrono::system_clock::now();
-  while (count == 0) {
-    status = cv.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
-    if (status == std::cv_status::timeout) {
-      return status;
+    std::cv_status status = std::cv_status::no_timeout;
+    auto now = std::chrono::system_clock::now();
+    while (count == 0) {
+        status = cv.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
+        if (status == std::cv_status::timeout) {
+            return status;
+        }
     }
-  }
-  count--;
-  return status;
+    count--;
+    return status;
 }
 
 bool RadioHidlTest::CheckGeneralError() {
@@ -64,10 +65,11 @@
             radioRsp->rspInfo.error == RadioError::NO_MEMORY ||
             radioRsp->rspInfo.error == RadioError::INTERNAL_ERR ||
             radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
-            radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
+            radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED ||
+            radioRsp->rspInfo.error == RadioError::CANCELLED);
 }
 
 bool RadioHidlTest::CheckOEMError() {
     return (radioRsp->rspInfo.error >= RadioError::OEM_ERROR_1 &&
             radioRsp->rspInfo.error <= RadioError::OEM_ERROR_25);
-}
\ No newline at end of file
+}
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_utils.h b/radio/1.0/vts/functional/radio_hidl_hal_utils.h
index 923e1e3..4db8a44 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_utils.h
+++ b/radio/1.0/vts/functional/radio_hidl_hal_utils.h
@@ -26,6 +26,8 @@
 #include <android/hardware/radio/1.0/IRadioResponse.h>
 #include <android/hardware/radio/1.0/types.h>
 
+#include <vts_test_util.h>
+
 using ::android::hardware::radio::V1_0::ActivityStatsInfo;
 using ::android::hardware::radio::V1_0::AppType;
 using ::android::hardware::radio::V1_0::CardStatus;
@@ -88,432 +90,388 @@
 
 /* Callback class for radio response */
 class RadioResponse : public IRadioResponse {
- private:
-  RadioHidlTest& parent;
+   private:
+    RadioHidlTest& parent;
 
- public:
-  RadioResponseInfo rspInfo;
-  hidl_string imsi;
-  IccIoResult iccIoResult;
-  int channelId;
+   public:
+    RadioResponseInfo rspInfo;
+    hidl_string imsi;
+    IccIoResult iccIoResult;
+    int channelId;
 
-  // Sms
-  SendSmsResult sendSmsResult;
-  hidl_string smscAddress;
-  uint32_t writeSmsToSimIndex;
-  uint32_t writeSmsToRuimIndex;
+    // Sms
+    SendSmsResult sendSmsResult;
+    hidl_string smscAddress;
+    uint32_t writeSmsToSimIndex;
+    uint32_t writeSmsToRuimIndex;
 
-  RadioResponse(RadioHidlTest& parent);
+    RadioResponse(RadioHidlTest& parent);
 
-  virtual ~RadioResponse() = default;
+    virtual ~RadioResponse() = default;
 
-  Return<void> getIccCardStatusResponse(const RadioResponseInfo& info,
-                                        const CardStatus& cardStatus);
+    Return<void> getIccCardStatusResponse(const RadioResponseInfo& info,
+                                          const CardStatus& cardStatus);
 
-  Return<void> supplyIccPinForAppResponse(const RadioResponseInfo& info,
-                                          int32_t remainingRetries);
+    Return<void> supplyIccPinForAppResponse(const RadioResponseInfo& info,
+                                            int32_t remainingRetries);
 
-  Return<void> supplyIccPukForAppResponse(const RadioResponseInfo& info,
-                                          int32_t remainingRetries);
+    Return<void> supplyIccPukForAppResponse(const RadioResponseInfo& info,
+                                            int32_t remainingRetries);
 
-  Return<void> supplyIccPin2ForAppResponse(const RadioResponseInfo& info,
-                                           int32_t remainingRetries);
+    Return<void> supplyIccPin2ForAppResponse(const RadioResponseInfo& info,
+                                             int32_t remainingRetries);
 
-  Return<void> supplyIccPuk2ForAppResponse(const RadioResponseInfo& info,
-                                           int32_t remainingRetries);
+    Return<void> supplyIccPuk2ForAppResponse(const RadioResponseInfo& info,
+                                             int32_t remainingRetries);
 
-  Return<void> changeIccPinForAppResponse(const RadioResponseInfo& info,
-                                          int32_t remainingRetries);
+    Return<void> changeIccPinForAppResponse(const RadioResponseInfo& info,
+                                            int32_t remainingRetries);
 
-  Return<void> changeIccPin2ForAppResponse(const RadioResponseInfo& info,
-                                           int32_t remainingRetries);
+    Return<void> changeIccPin2ForAppResponse(const RadioResponseInfo& info,
+                                             int32_t remainingRetries);
 
-  Return<void> supplyNetworkDepersonalizationResponse(
-      const RadioResponseInfo& info, int32_t remainingRetries);
+    Return<void> supplyNetworkDepersonalizationResponse(const RadioResponseInfo& info,
+                                                        int32_t remainingRetries);
 
-  Return<void> getCurrentCallsResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<Call>& calls);
+    Return<void> getCurrentCallsResponse(const RadioResponseInfo& info,
+                                         const ::android::hardware::hidl_vec<Call>& calls);
 
-  Return<void> dialResponse(const RadioResponseInfo& info);
+    Return<void> dialResponse(const RadioResponseInfo& info);
 
-  Return<void> getIMSIForAppResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_string& imsi);
+    Return<void> getIMSIForAppResponse(const RadioResponseInfo& info,
+                                       const ::android::hardware::hidl_string& imsi);
 
-  Return<void> hangupConnectionResponse(const RadioResponseInfo& info);
+    Return<void> hangupConnectionResponse(const RadioResponseInfo& info);
 
-  Return<void> hangupWaitingOrBackgroundResponse(const RadioResponseInfo& info);
+    Return<void> hangupWaitingOrBackgroundResponse(const RadioResponseInfo& info);
 
-  Return<void> hangupForegroundResumeBackgroundResponse(
-      const RadioResponseInfo& info);
+    Return<void> hangupForegroundResumeBackgroundResponse(const RadioResponseInfo& info);
 
-  Return<void> switchWaitingOrHoldingAndActiveResponse(
-      const RadioResponseInfo& info);
+    Return<void> switchWaitingOrHoldingAndActiveResponse(const RadioResponseInfo& info);
 
-  Return<void> conferenceResponse(const RadioResponseInfo& info);
+    Return<void> conferenceResponse(const RadioResponseInfo& info);
 
-  Return<void> rejectCallResponse(const RadioResponseInfo& info);
+    Return<void> rejectCallResponse(const RadioResponseInfo& info);
 
-  Return<void> getLastCallFailCauseResponse(
-      const RadioResponseInfo& info,
-      const LastCallFailCauseInfo& failCauseInfo);
+    Return<void> getLastCallFailCauseResponse(const RadioResponseInfo& info,
+                                              const LastCallFailCauseInfo& failCauseInfo);
 
-  Return<void> getSignalStrengthResponse(const RadioResponseInfo& info,
-                                         const SignalStrength& sigStrength);
+    Return<void> getSignalStrengthResponse(const RadioResponseInfo& info,
+                                           const SignalStrength& sigStrength);
 
-  Return<void> getVoiceRegistrationStateResponse(
-      const RadioResponseInfo& info,
-      const VoiceRegStateResult& voiceRegResponse);
+    Return<void> getVoiceRegistrationStateResponse(const RadioResponseInfo& info,
+                                                   const VoiceRegStateResult& voiceRegResponse);
 
-  Return<void> getDataRegistrationStateResponse(
-      const RadioResponseInfo& info, const DataRegStateResult& dataRegResponse);
+    Return<void> getDataRegistrationStateResponse(const RadioResponseInfo& info,
+                                                  const DataRegStateResult& dataRegResponse);
 
-  Return<void> getOperatorResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_string& longName,
-      const ::android::hardware::hidl_string& shortName,
-      const ::android::hardware::hidl_string& numeric);
+    Return<void> getOperatorResponse(const RadioResponseInfo& info,
+                                     const ::android::hardware::hidl_string& longName,
+                                     const ::android::hardware::hidl_string& shortName,
+                                     const ::android::hardware::hidl_string& numeric);
 
-  Return<void> setRadioPowerResponse(const RadioResponseInfo& info);
+    Return<void> setRadioPowerResponse(const RadioResponseInfo& info);
 
-  Return<void> sendDtmfResponse(const RadioResponseInfo& info);
+    Return<void> sendDtmfResponse(const RadioResponseInfo& info);
 
-  Return<void> sendSmsResponse(const RadioResponseInfo& info,
-                               const SendSmsResult& sms);
+    Return<void> sendSmsResponse(const RadioResponseInfo& info, const SendSmsResult& sms);
 
-  Return<void> sendSMSExpectMoreResponse(const RadioResponseInfo& info,
-                                         const SendSmsResult& sms);
+    Return<void> sendSMSExpectMoreResponse(const RadioResponseInfo& info, const SendSmsResult& sms);
 
-  Return<void> setupDataCallResponse(const RadioResponseInfo& info,
-                                     const SetupDataCallResult& dcResponse);
+    Return<void> setupDataCallResponse(const RadioResponseInfo& info,
+                                       const SetupDataCallResult& dcResponse);
 
-  Return<void> iccIOForAppResponse(const RadioResponseInfo& info,
-                                   const IccIoResult& iccIo);
+    Return<void> iccIOForAppResponse(const RadioResponseInfo& info, const IccIoResult& iccIo);
 
-  Return<void> sendUssdResponse(const RadioResponseInfo& info);
+    Return<void> sendUssdResponse(const RadioResponseInfo& info);
 
-  Return<void> cancelPendingUssdResponse(const RadioResponseInfo& info);
+    Return<void> cancelPendingUssdResponse(const RadioResponseInfo& info);
 
-  Return<void> getClirResponse(const RadioResponseInfo& info, int32_t n,
-                               int32_t m);
+    Return<void> getClirResponse(const RadioResponseInfo& info, int32_t n, int32_t m);
 
-  Return<void> setClirResponse(const RadioResponseInfo& info);
+    Return<void> setClirResponse(const RadioResponseInfo& info);
 
-  Return<void> getCallForwardStatusResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<CallForwardInfo>& call_forwardInfos);
+    Return<void> getCallForwardStatusResponse(
+        const RadioResponseInfo& info,
+        const ::android::hardware::hidl_vec<CallForwardInfo>& call_forwardInfos);
 
-  Return<void> setCallForwardResponse(const RadioResponseInfo& info);
+    Return<void> setCallForwardResponse(const RadioResponseInfo& info);
 
-  Return<void> getCallWaitingResponse(const RadioResponseInfo& info,
-                                      bool enable, int32_t serviceClass);
+    Return<void> getCallWaitingResponse(const RadioResponseInfo& info, bool enable,
+                                        int32_t serviceClass);
 
-  Return<void> setCallWaitingResponse(const RadioResponseInfo& info);
+    Return<void> setCallWaitingResponse(const RadioResponseInfo& info);
 
-  Return<void> acknowledgeLastIncomingGsmSmsResponse(
-      const RadioResponseInfo& info);
+    Return<void> acknowledgeLastIncomingGsmSmsResponse(const RadioResponseInfo& info);
 
-  Return<void> acceptCallResponse(const RadioResponseInfo& info);
+    Return<void> acceptCallResponse(const RadioResponseInfo& info);
 
-  Return<void> deactivateDataCallResponse(const RadioResponseInfo& info);
+    Return<void> deactivateDataCallResponse(const RadioResponseInfo& info);
 
-  Return<void> getFacilityLockForAppResponse(const RadioResponseInfo& info,
-                                             int32_t response);
+    Return<void> getFacilityLockForAppResponse(const RadioResponseInfo& info, int32_t response);
 
-  Return<void> setFacilityLockForAppResponse(const RadioResponseInfo& info,
-                                             int32_t retry);
+    Return<void> setFacilityLockForAppResponse(const RadioResponseInfo& info, int32_t retry);
 
-  Return<void> setBarringPasswordResponse(const RadioResponseInfo& info);
+    Return<void> setBarringPasswordResponse(const RadioResponseInfo& info);
 
-  Return<void> getNetworkSelectionModeResponse(const RadioResponseInfo& info,
-                                               bool manual);
+    Return<void> getNetworkSelectionModeResponse(const RadioResponseInfo& info, bool manual);
 
-  Return<void> setNetworkSelectionModeAutomaticResponse(
-      const RadioResponseInfo& info);
+    Return<void> setNetworkSelectionModeAutomaticResponse(const RadioResponseInfo& info);
 
-  Return<void> setNetworkSelectionModeManualResponse(
-      const RadioResponseInfo& info);
+    Return<void> setNetworkSelectionModeManualResponse(const RadioResponseInfo& info);
 
-  Return<void> getAvailableNetworksResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<OperatorInfo>& networkInfos);
+    Return<void> getAvailableNetworksResponse(
+        const RadioResponseInfo& info,
+        const ::android::hardware::hidl_vec<OperatorInfo>& networkInfos);
 
-  Return<void> startDtmfResponse(const RadioResponseInfo& info);
+    Return<void> startDtmfResponse(const RadioResponseInfo& info);
 
-  Return<void> stopDtmfResponse(const RadioResponseInfo& info);
+    Return<void> stopDtmfResponse(const RadioResponseInfo& info);
 
-  Return<void> getBasebandVersionResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_string& version);
+    Return<void> getBasebandVersionResponse(const RadioResponseInfo& info,
+                                            const ::android::hardware::hidl_string& version);
 
-  Return<void> separateConnectionResponse(const RadioResponseInfo& info);
+    Return<void> separateConnectionResponse(const RadioResponseInfo& info);
 
-  Return<void> setMuteResponse(const RadioResponseInfo& info);
+    Return<void> setMuteResponse(const RadioResponseInfo& info);
 
-  Return<void> getMuteResponse(const RadioResponseInfo& info, bool enable);
+    Return<void> getMuteResponse(const RadioResponseInfo& info, bool enable);
 
-  Return<void> getClipResponse(const RadioResponseInfo& info,
-                               ClipStatus status);
+    Return<void> getClipResponse(const RadioResponseInfo& info, ClipStatus status);
 
-  Return<void> getDataCallListResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<SetupDataCallResult>& dcResponse);
+    Return<void> getDataCallListResponse(
+        const RadioResponseInfo& info,
+        const ::android::hardware::hidl_vec<SetupDataCallResult>& dcResponse);
 
-  Return<void> sendOemRilRequestRawResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<uint8_t>& data);
+    Return<void> sendOemRilRequestRawResponse(const RadioResponseInfo& info,
+                                              const ::android::hardware::hidl_vec<uint8_t>& data);
 
-  Return<void> sendOemRilRequestStringsResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<::android::hardware::hidl_string>&
-          data);
+    Return<void> sendOemRilRequestStringsResponse(
+        const RadioResponseInfo& info,
+        const ::android::hardware::hidl_vec<::android::hardware::hidl_string>& data);
 
-  Return<void> setSuppServiceNotificationsResponse(
-      const RadioResponseInfo& info);
+    Return<void> setSuppServiceNotificationsResponse(const RadioResponseInfo& info);
 
-  Return<void> writeSmsToSimResponse(const RadioResponseInfo& info,
-                                     int32_t index);
+    Return<void> writeSmsToSimResponse(const RadioResponseInfo& info, int32_t index);
 
-  Return<void> deleteSmsOnSimResponse(const RadioResponseInfo& info);
+    Return<void> deleteSmsOnSimResponse(const RadioResponseInfo& info);
 
-  Return<void> setBandModeResponse(const RadioResponseInfo& info);
+    Return<void> setBandModeResponse(const RadioResponseInfo& info);
 
-  Return<void> getAvailableBandModesResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<RadioBandMode>& bandModes);
+    Return<void> getAvailableBandModesResponse(
+        const RadioResponseInfo& info,
+        const ::android::hardware::hidl_vec<RadioBandMode>& bandModes);
 
-  Return<void> sendEnvelopeResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_string& commandResponse);
+    Return<void> sendEnvelopeResponse(const RadioResponseInfo& info,
+                                      const ::android::hardware::hidl_string& commandResponse);
 
-  Return<void> sendTerminalResponseToSimResponse(const RadioResponseInfo& info);
+    Return<void> sendTerminalResponseToSimResponse(const RadioResponseInfo& info);
 
-  Return<void> handleStkCallSetupRequestFromSimResponse(
-      const RadioResponseInfo& info);
+    Return<void> handleStkCallSetupRequestFromSimResponse(const RadioResponseInfo& info);
 
-  Return<void> explicitCallTransferResponse(const RadioResponseInfo& info);
+    Return<void> explicitCallTransferResponse(const RadioResponseInfo& info);
 
-  Return<void> setPreferredNetworkTypeResponse(const RadioResponseInfo& info);
+    Return<void> setPreferredNetworkTypeResponse(const RadioResponseInfo& info);
 
-  Return<void> getPreferredNetworkTypeResponse(const RadioResponseInfo& info,
-                                               PreferredNetworkType nwType);
+    Return<void> getPreferredNetworkTypeResponse(const RadioResponseInfo& info,
+                                                 PreferredNetworkType nwType);
 
-  Return<void> getNeighboringCidsResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<NeighboringCell>& cells);
+    Return<void> getNeighboringCidsResponse(
+        const RadioResponseInfo& info, const ::android::hardware::hidl_vec<NeighboringCell>& cells);
 
-  Return<void> setLocationUpdatesResponse(const RadioResponseInfo& info);
+    Return<void> setLocationUpdatesResponse(const RadioResponseInfo& info);
 
-  Return<void> setCdmaSubscriptionSourceResponse(const RadioResponseInfo& info);
+    Return<void> setCdmaSubscriptionSourceResponse(const RadioResponseInfo& info);
 
-  Return<void> setCdmaRoamingPreferenceResponse(const RadioResponseInfo& info);
+    Return<void> setCdmaRoamingPreferenceResponse(const RadioResponseInfo& info);
 
-  Return<void> getCdmaRoamingPreferenceResponse(const RadioResponseInfo& info,
-                                                CdmaRoamingType type);
+    Return<void> getCdmaRoamingPreferenceResponse(const RadioResponseInfo& info,
+                                                  CdmaRoamingType type);
 
-  Return<void> setTTYModeResponse(const RadioResponseInfo& info);
+    Return<void> setTTYModeResponse(const RadioResponseInfo& info);
 
-  Return<void> getTTYModeResponse(const RadioResponseInfo& info, TtyMode mode);
+    Return<void> getTTYModeResponse(const RadioResponseInfo& info, TtyMode mode);
 
-  Return<void> setPreferredVoicePrivacyResponse(const RadioResponseInfo& info);
+    Return<void> setPreferredVoicePrivacyResponse(const RadioResponseInfo& info);
 
-  Return<void> getPreferredVoicePrivacyResponse(const RadioResponseInfo& info,
-                                                bool enable);
+    Return<void> getPreferredVoicePrivacyResponse(const RadioResponseInfo& info, bool enable);
 
-  Return<void> sendCDMAFeatureCodeResponse(const RadioResponseInfo& info);
+    Return<void> sendCDMAFeatureCodeResponse(const RadioResponseInfo& info);
 
-  Return<void> sendBurstDtmfResponse(const RadioResponseInfo& info);
+    Return<void> sendBurstDtmfResponse(const RadioResponseInfo& info);
 
-  Return<void> sendCdmaSmsResponse(const RadioResponseInfo& info,
-                                   const SendSmsResult& sms);
+    Return<void> sendCdmaSmsResponse(const RadioResponseInfo& info, const SendSmsResult& sms);
 
-  Return<void> acknowledgeLastIncomingCdmaSmsResponse(
-      const RadioResponseInfo& info);
+    Return<void> acknowledgeLastIncomingCdmaSmsResponse(const RadioResponseInfo& info);
 
-  Return<void> getGsmBroadcastConfigResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>& configs);
+    Return<void> getGsmBroadcastConfigResponse(
+        const RadioResponseInfo& info,
+        const ::android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>& configs);
 
-  Return<void> setGsmBroadcastConfigResponse(const RadioResponseInfo& info);
+    Return<void> setGsmBroadcastConfigResponse(const RadioResponseInfo& info);
 
-  Return<void> setGsmBroadcastActivationResponse(const RadioResponseInfo& info);
+    Return<void> setGsmBroadcastActivationResponse(const RadioResponseInfo& info);
 
-  Return<void> getCdmaBroadcastConfigResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>& configs);
+    Return<void> getCdmaBroadcastConfigResponse(
+        const RadioResponseInfo& info,
+        const ::android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>& configs);
 
-  Return<void> setCdmaBroadcastConfigResponse(const RadioResponseInfo& info);
+    Return<void> setCdmaBroadcastConfigResponse(const RadioResponseInfo& info);
 
-  Return<void> setCdmaBroadcastActivationResponse(
-      const RadioResponseInfo& info);
+    Return<void> setCdmaBroadcastActivationResponse(const RadioResponseInfo& info);
 
-  Return<void> getCDMASubscriptionResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_string& mdn,
-      const ::android::hardware::hidl_string& hSid,
-      const ::android::hardware::hidl_string& hNid,
-      const ::android::hardware::hidl_string& min,
-      const ::android::hardware::hidl_string& prl);
+    Return<void> getCDMASubscriptionResponse(const RadioResponseInfo& info,
+                                             const ::android::hardware::hidl_string& mdn,
+                                             const ::android::hardware::hidl_string& hSid,
+                                             const ::android::hardware::hidl_string& hNid,
+                                             const ::android::hardware::hidl_string& min,
+                                             const ::android::hardware::hidl_string& prl);
 
-  Return<void> writeSmsToRuimResponse(const RadioResponseInfo& info,
-                                      uint32_t index);
+    Return<void> writeSmsToRuimResponse(const RadioResponseInfo& info, uint32_t index);
 
-  Return<void> deleteSmsOnRuimResponse(const RadioResponseInfo& info);
+    Return<void> deleteSmsOnRuimResponse(const RadioResponseInfo& info);
 
-  Return<void> getDeviceIdentityResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_string& imei,
-      const ::android::hardware::hidl_string& imeisv,
-      const ::android::hardware::hidl_string& esn,
-      const ::android::hardware::hidl_string& meid);
+    Return<void> getDeviceIdentityResponse(const RadioResponseInfo& info,
+                                           const ::android::hardware::hidl_string& imei,
+                                           const ::android::hardware::hidl_string& imeisv,
+                                           const ::android::hardware::hidl_string& esn,
+                                           const ::android::hardware::hidl_string& meid);
 
-  Return<void> exitEmergencyCallbackModeResponse(const RadioResponseInfo& info);
+    Return<void> exitEmergencyCallbackModeResponse(const RadioResponseInfo& info);
 
-  Return<void> getSmscAddressResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_string& smsc);
+    Return<void> getSmscAddressResponse(const RadioResponseInfo& info,
+                                        const ::android::hardware::hidl_string& smsc);
 
-  Return<void> setSmscAddressResponse(const RadioResponseInfo& info);
+    Return<void> setSmscAddressResponse(const RadioResponseInfo& info);
 
-  Return<void> reportSmsMemoryStatusResponse(const RadioResponseInfo& info);
+    Return<void> reportSmsMemoryStatusResponse(const RadioResponseInfo& info);
 
-  Return<void> reportStkServiceIsRunningResponse(const RadioResponseInfo& info);
+    Return<void> reportStkServiceIsRunningResponse(const RadioResponseInfo& info);
 
-  Return<void> getCdmaSubscriptionSourceResponse(const RadioResponseInfo& info,
-                                                 CdmaSubscriptionSource source);
+    Return<void> getCdmaSubscriptionSourceResponse(const RadioResponseInfo& info,
+                                                   CdmaSubscriptionSource source);
 
-  Return<void> requestIsimAuthenticationResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_string& response);
+    Return<void> requestIsimAuthenticationResponse(
+        const RadioResponseInfo& info, const ::android::hardware::hidl_string& response);
 
-  Return<void> acknowledgeIncomingGsmSmsWithPduResponse(
-      const RadioResponseInfo& info);
+    Return<void> acknowledgeIncomingGsmSmsWithPduResponse(const RadioResponseInfo& info);
 
-  Return<void> sendEnvelopeWithStatusResponse(const RadioResponseInfo& info,
-                                              const IccIoResult& iccIo);
+    Return<void> sendEnvelopeWithStatusResponse(const RadioResponseInfo& info,
+                                                const IccIoResult& iccIo);
 
-  Return<void> getVoiceRadioTechnologyResponse(const RadioResponseInfo& info,
-                                               RadioTechnology rat);
+    Return<void> getVoiceRadioTechnologyResponse(const RadioResponseInfo& info,
+                                                 RadioTechnology rat);
 
-  Return<void> getCellInfoListResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<CellInfo>& cellInfo);
+    Return<void> getCellInfoListResponse(const RadioResponseInfo& info,
+                                         const ::android::hardware::hidl_vec<CellInfo>& cellInfo);
 
-  Return<void> setCellInfoListRateResponse(const RadioResponseInfo& info);
+    Return<void> setCellInfoListRateResponse(const RadioResponseInfo& info);
 
-  Return<void> setInitialAttachApnResponse(const RadioResponseInfo& info);
+    Return<void> setInitialAttachApnResponse(const RadioResponseInfo& info);
 
-  Return<void> getImsRegistrationStateResponse(const RadioResponseInfo& info,
-                                               bool isRegistered,
-                                               RadioTechnologyFamily ratFamily);
+    Return<void> getImsRegistrationStateResponse(const RadioResponseInfo& info, bool isRegistered,
+                                                 RadioTechnologyFamily ratFamily);
 
-  Return<void> sendImsSmsResponse(const RadioResponseInfo& info,
-                                  const SendSmsResult& sms);
+    Return<void> sendImsSmsResponse(const RadioResponseInfo& info, const SendSmsResult& sms);
 
-  Return<void> iccTransmitApduBasicChannelResponse(
-      const RadioResponseInfo& info, const IccIoResult& result);
+    Return<void> iccTransmitApduBasicChannelResponse(const RadioResponseInfo& info,
+                                                     const IccIoResult& result);
 
-  Return<void> iccOpenLogicalChannelResponse(
-      const RadioResponseInfo& info, int32_t channelId,
-      const ::android::hardware::hidl_vec<int8_t>& selectResponse);
+    Return<void> iccOpenLogicalChannelResponse(
+        const RadioResponseInfo& info, int32_t channelId,
+        const ::android::hardware::hidl_vec<int8_t>& selectResponse);
 
-  Return<void> iccCloseLogicalChannelResponse(const RadioResponseInfo& info);
+    Return<void> iccCloseLogicalChannelResponse(const RadioResponseInfo& info);
 
-  Return<void> iccTransmitApduLogicalChannelResponse(
-      const RadioResponseInfo& info, const IccIoResult& result);
+    Return<void> iccTransmitApduLogicalChannelResponse(const RadioResponseInfo& info,
+                                                       const IccIoResult& result);
 
-  Return<void> nvReadItemResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_string& result);
+    Return<void> nvReadItemResponse(const RadioResponseInfo& info,
+                                    const ::android::hardware::hidl_string& result);
 
-  Return<void> nvWriteItemResponse(const RadioResponseInfo& info);
+    Return<void> nvWriteItemResponse(const RadioResponseInfo& info);
 
-  Return<void> nvWriteCdmaPrlResponse(const RadioResponseInfo& info);
+    Return<void> nvWriteCdmaPrlResponse(const RadioResponseInfo& info);
 
-  Return<void> nvResetConfigResponse(const RadioResponseInfo& info);
+    Return<void> nvResetConfigResponse(const RadioResponseInfo& info);
 
-  Return<void> setUiccSubscriptionResponse(const RadioResponseInfo& info);
+    Return<void> setUiccSubscriptionResponse(const RadioResponseInfo& info);
 
-  Return<void> setDataAllowedResponse(const RadioResponseInfo& info);
+    Return<void> setDataAllowedResponse(const RadioResponseInfo& info);
 
-  Return<void> getHardwareConfigResponse(
-      const RadioResponseInfo& info,
-      const ::android::hardware::hidl_vec<HardwareConfig>& config);
+    Return<void> getHardwareConfigResponse(
+        const RadioResponseInfo& info, const ::android::hardware::hidl_vec<HardwareConfig>& config);
 
-  Return<void> requestIccSimAuthenticationResponse(
-      const RadioResponseInfo& info, const IccIoResult& result);
+    Return<void> requestIccSimAuthenticationResponse(const RadioResponseInfo& info,
+                                                     const IccIoResult& result);
 
-  Return<void> setDataProfileResponse(const RadioResponseInfo& info);
+    Return<void> setDataProfileResponse(const RadioResponseInfo& info);
 
-  Return<void> requestShutdownResponse(const RadioResponseInfo& info);
+    Return<void> requestShutdownResponse(const RadioResponseInfo& info);
 
-  Return<void> getRadioCapabilityResponse(const RadioResponseInfo& info,
-                                          const RadioCapability& rc);
+    Return<void> getRadioCapabilityResponse(const RadioResponseInfo& info,
+                                            const RadioCapability& rc);
 
-  Return<void> setRadioCapabilityResponse(const RadioResponseInfo& info,
-                                          const RadioCapability& rc);
+    Return<void> setRadioCapabilityResponse(const RadioResponseInfo& info,
+                                            const RadioCapability& rc);
 
-  Return<void> startLceServiceResponse(const RadioResponseInfo& info,
-                                       const LceStatusInfo& statusInfo);
+    Return<void> startLceServiceResponse(const RadioResponseInfo& info,
+                                         const LceStatusInfo& statusInfo);
 
-  Return<void> stopLceServiceResponse(const RadioResponseInfo& info,
-                                      const LceStatusInfo& statusInfo);
+    Return<void> stopLceServiceResponse(const RadioResponseInfo& info,
+                                        const LceStatusInfo& statusInfo);
 
-  Return<void> pullLceDataResponse(const RadioResponseInfo& info,
-                                   const LceDataInfo& lceInfo);
+    Return<void> pullLceDataResponse(const RadioResponseInfo& info, const LceDataInfo& lceInfo);
 
-  Return<void> getModemActivityInfoResponse(
-      const RadioResponseInfo& info, const ActivityStatsInfo& activityInfo);
+    Return<void> getModemActivityInfoResponse(const RadioResponseInfo& info,
+                                              const ActivityStatsInfo& activityInfo);
 
-  Return<void> setAllowedCarriersResponse(const RadioResponseInfo& info,
-                                          int32_t numAllowed);
+    Return<void> setAllowedCarriersResponse(const RadioResponseInfo& info, int32_t numAllowed);
 
-  Return<void> getAllowedCarriersResponse(const RadioResponseInfo& info,
-                                          bool allAllowed,
-                                          const CarrierRestrictions& carriers);
+    Return<void> getAllowedCarriersResponse(const RadioResponseInfo& info, bool allAllowed,
+                                            const CarrierRestrictions& carriers);
 
-  Return<void> sendDeviceStateResponse(const RadioResponseInfo& info);
+    Return<void> sendDeviceStateResponse(const RadioResponseInfo& info);
 
-  Return<void> setIndicationFilterResponse(const RadioResponseInfo& info);
+    Return<void> setIndicationFilterResponse(const RadioResponseInfo& info);
 
-  Return<void> setSimCardPowerResponse(const RadioResponseInfo& info);
+    Return<void> setSimCardPowerResponse(const RadioResponseInfo& info);
 
-  Return<void> acknowledgeRequest(int32_t serial);
+    Return<void> acknowledgeRequest(int32_t serial);
 };
 
 // The main test class for Radio HIDL.
 class RadioHidlTest : public ::testing::VtsHalHidlTargetTestBase {
- private:
-  std::mutex mtx;
-  std::condition_variable cv;
-  int count;
+   private:
+    std::mutex mtx;
+    std::condition_variable cv;
+    int count;
 
- public:
-  virtual void SetUp() override;
+   public:
+    virtual void SetUp() override;
 
-  virtual void TearDown() override;
+    virtual void TearDown() override;
 
-  /* Used as a mechanism to inform the test about data/event callback */
-  void notify();
+    /* Used as a mechanism to inform the test about data/event callback */
+    void notify();
 
-  /* Test code calls this function to wait for response */
-  std::cv_status wait();
+    /* Test code calls this function to wait for response */
+    std::cv_status wait();
 
-  /* Used for checking General Errors */
-  bool CheckGeneralError();
+    /* Used for checking General Errors */
+    bool CheckGeneralError();
 
-  /* Used for checking OEM Errors */
-  bool CheckOEMError();
+    /* Used for checking OEM Errors */
+    bool CheckOEMError();
 
-  sp<IRadio> radio;
-  sp<RadioResponse> radioRsp;
-  sp<IRadioIndication> radioInd;
+    sp<IRadio> radio;
+    sp<RadioResponse> radioRsp;
+    sp<IRadioIndication> radioInd;
 };
 
 // A class for test environment setup
 class RadioHidlEnvironment : public ::testing::Environment {
- public:
-  virtual void SetUp() {}
-  virtual void TearDown() {}
+   public:
+    virtual void SetUp() {}
+    virtual void TearDown() {}
 };
\ No newline at end of file
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_voice.cpp b/radio/1.0/vts/functional/radio_hidl_hal_voice.cpp
index b96269a..95d00e3 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_voice.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_voice.cpp
@@ -20,477 +20,467 @@
  * Test IRadio.getCurrentCalls() for the response returned.
  */
 TEST_F(RadioHidlTest, getCurrentCalls) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getCurrentCalls(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getCurrentCalls(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.dial() for the response returned.
  */
 TEST_F(RadioHidlTest, dial) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  Dial dialInfo;
-  memset(&dialInfo, 0, sizeof(dialInfo));
-  dialInfo.address = hidl_string("123456789");
+    Dial dialInfo;
+    memset(&dialInfo, 0, sizeof(dialInfo));
+    dialInfo.address = hidl_string("123456789");
 
-  radio->dial(serial, dialInfo);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->dial(serial, dialInfo);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
-                  radioRsp->rspInfo.error == RadioError::FDN_CHECK_FAILURE ||
-                  radioRsp->rspInfo.error == RadioError::NO_SUBSCRIPTION ||
-                  radioRsp->rspInfo.error == RadioError::NO_NETWORK_FOUND ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
-                  radioRsp->rspInfo.error == RadioError::DEVICE_IN_USE ||
-                  radioRsp->rspInfo.error == RadioError::MODE_NOT_SUPPORTED ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
-                  radioRsp->rspInfo.error == RadioError::CANCELLED);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                    radioRsp->rspInfo.error == RadioError::FDN_CHECK_FAILURE ||
+                    radioRsp->rspInfo.error == RadioError::NO_SUBSCRIPTION ||
+                    radioRsp->rspInfo.error == RadioError::NO_NETWORK_FOUND ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
+                    radioRsp->rspInfo.error == RadioError::DEVICE_IN_USE ||
+                    radioRsp->rspInfo.error == RadioError::MODE_NOT_SUPPORTED ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
+                    radioRsp->rspInfo.error == RadioError::CANCELLED);
+    }
 }
 
 /*
  * Test IRadio.hangup() for the response returned.
  */
 TEST_F(RadioHidlTest, hangup) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->hangup(serial, 1);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->hangup(serial, 1);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.hangupWaitingOrBackground() for the response returned.
  */
 TEST_F(RadioHidlTest, hangupWaitingOrBackground) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->hangupWaitingOrBackground(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->hangupWaitingOrBackground(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.hangupForegroundResumeBackground() for the response returned.
  */
 TEST_F(RadioHidlTest, hangupForegroundResumeBackground) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->hangupForegroundResumeBackground(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->hangupForegroundResumeBackground(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.switchWaitingOrHoldingAndActive() for the response returned.
  */
 TEST_F(RadioHidlTest, switchWaitingOrHoldingAndActive) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->switchWaitingOrHoldingAndActive(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->switchWaitingOrHoldingAndActive(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.conference() for the response returned.
  */
 TEST_F(RadioHidlTest, conference) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->conference(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->conference(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.rejectCall() for the response returned.
  */
 TEST_F(RadioHidlTest, rejectCall) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->rejectCall(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->rejectCall(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.getLastCallFailCause() for the response returned.
  */
 TEST_F(RadioHidlTest, getLastCallFailCause) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getLastCallFailCause(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getLastCallFailCause(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.sendUssd() for the response returned.
  */
 TEST_F(RadioHidlTest, sendUssd) {
-  int serial = 1;
-  radio->sendUssd(serial, hidl_string("test"));
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    int serial = GetRandomSerialNumber();
+    radio->sendUssd(serial, hidl_string("test"));
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.cancelPendingUssd() for the response returned.
  */
 TEST_F(RadioHidlTest, cancelPendingUssd) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->cancelPendingUssd(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->cancelPendingUssd(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.getCallForwardStatus() for the response returned.
  */
 TEST_F(RadioHidlTest, getCallForwardStatus) {
-  int serial = 1;
-  CallForwardInfo callInfo;
-  memset(&callInfo, 0, sizeof(callInfo));
-  callInfo.number = hidl_string();
+    int serial = GetRandomSerialNumber();
+    CallForwardInfo callInfo;
+    memset(&callInfo, 0, sizeof(callInfo));
+    callInfo.number = hidl_string();
 
-  radio->getCallForwardStatus(serial, callInfo);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getCallForwardStatus(serial, callInfo);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.setCallForward() for the response returned.
  */
 TEST_F(RadioHidlTest, setCallForward) {
-  int serial = 1;
-  CallForwardInfo callInfo;
-  memset(&callInfo, 0, sizeof(callInfo));
-  callInfo.number = hidl_string();
+    int serial = GetRandomSerialNumber();
+    CallForwardInfo callInfo;
+    memset(&callInfo, 0, sizeof(callInfo));
+    callInfo.number = hidl_string();
 
-  radio->setCallForward(serial, callInfo);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setCallForward(serial, callInfo);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.getCallWaiting() for the response returned.
  */
 TEST_F(RadioHidlTest, getCallWaiting) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getCallWaiting(serial, 1);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getCallWaiting(serial, 1);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.setCallWaiting() for the response returned.
  */
 TEST_F(RadioHidlTest, setCallWaiting) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setCallWaiting(serial, true, 1);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setCallWaiting(serial, true, 1);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.acceptCall() for the response returned.
  */
 TEST_F(RadioHidlTest, acceptCall) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->acceptCall(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->acceptCall(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.separateConnection() for the response returned.
  */
 TEST_F(RadioHidlTest, separateConnection) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->separateConnection(serial, 1);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->separateConnection(serial, 1);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.explicitCallTransfer() for the response returned.
  */
 TEST_F(RadioHidlTest, explicitCallTransfer) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->explicitCallTransfer(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->explicitCallTransfer(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.sendCDMAFeatureCode() for the response returned.
  */
 TEST_F(RadioHidlTest, sendCDMAFeatureCode) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->sendCDMAFeatureCode(serial, hidl_string());
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->sendCDMAFeatureCode(serial, hidl_string());
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.sendDtmf() for the response returned.
  */
 TEST_F(RadioHidlTest, sendDtmf) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->sendDtmf(serial, "1");
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->sendDtmf(serial, "1");
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.startDtmf() for the response returned.
  */
 TEST_F(RadioHidlTest, startDtmf) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->startDtmf(serial, "1");
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->startDtmf(serial, "1");
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.stopDtmf() for the response returned.
  */
 TEST_F(RadioHidlTest, stopDtmf) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->stopDtmf(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->stopDtmf(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::NONE ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
 
 /*
  * Test IRadio.setMute() for the response returned.
  */
 TEST_F(RadioHidlTest, setMute) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->setMute(serial, true);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->setMute(serial, true);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.getMute() for the response returned.
  */
 TEST_F(RadioHidlTest, getMute) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->getMute(serial);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->getMute(serial);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+    }
 }
 
 /*
  * Test IRadio.sendBurstDtmf() for the response returned.
  */
 TEST_F(RadioHidlTest, sendBurstDtmf) {
-  int serial = 1;
+    int serial = GetRandomSerialNumber();
 
-  radio->sendBurstDtmf(serial, "1", 0, 0);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-  EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+    radio->sendBurstDtmf(serial, "1", 0, 0);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 
-  if (cardStatus.cardState == CardState::ABSENT) {
-      ASSERT_TRUE(CheckGeneralError() ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
-                  radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
-                  radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-  }
+    if (cardStatus.cardState == CardState::ABSENT) {
+        ASSERT_TRUE(CheckGeneralError() ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                    radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+    }
 }
\ No newline at end of file
diff --git a/radio/1.0/vts/functional/radio_response.cpp b/radio/1.0/vts/functional/radio_response.cpp
index 22c20a5..ef887eb 100644
--- a/radio/1.0/vts/functional/radio_response.cpp
+++ b/radio/1.0/vts/functional/radio_response.cpp
@@ -20,953 +20,884 @@
 
 RadioResponse::RadioResponse(RadioHidlTest& parent) : parent(parent) {}
 
-Return<void> RadioResponse::getIccCardStatusResponse(
-    const RadioResponseInfo& info, const CardStatus& card_status) {
-  rspInfo = info;
-  cardStatus = card_status;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getIccCardStatusResponse(const RadioResponseInfo& info,
+                                                     const CardStatus& card_status) {
+    rspInfo = info;
+    cardStatus = card_status;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::supplyIccPinForAppResponse(
-    const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::supplyIccPinForAppResponse(const RadioResponseInfo& info,
+                                                       int32_t /*remainingRetries*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::supplyIccPukForAppResponse(
-    const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::supplyIccPukForAppResponse(const RadioResponseInfo& info,
+                                                       int32_t /*remainingRetries*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::supplyIccPin2ForAppResponse(
-    const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::supplyIccPin2ForAppResponse(const RadioResponseInfo& info,
+                                                        int32_t /*remainingRetries*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::supplyIccPuk2ForAppResponse(
-    const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::supplyIccPuk2ForAppResponse(const RadioResponseInfo& info,
+                                                        int32_t /*remainingRetries*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::changeIccPinForAppResponse(
-    const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::changeIccPinForAppResponse(const RadioResponseInfo& info,
+                                                       int32_t /*remainingRetries*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::changeIccPin2ForAppResponse(
-    const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::changeIccPin2ForAppResponse(const RadioResponseInfo& info,
+                                                        int32_t /*remainingRetries*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::supplyNetworkDepersonalizationResponse(
-    const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::supplyNetworkDepersonalizationResponse(const RadioResponseInfo& info,
+                                                                   int32_t /*remainingRetries*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getCurrentCallsResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_vec<Call>& /*calls*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    const RadioResponseInfo& info, const ::android::hardware::hidl_vec<Call>& /*calls*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::dialResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getIMSIForAppResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_string& imsi) {
-  rspInfo = info;
-  this->imsi = imsi;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getIMSIForAppResponse(const RadioResponseInfo& info,
+                                                  const ::android::hardware::hidl_string& imsi) {
+    rspInfo = info;
+    this->imsi = imsi;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::hangupConnectionResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::hangupConnectionResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::hangupWaitingOrBackgroundResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::hangupWaitingOrBackgroundResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::hangupForegroundResumeBackgroundResponse(
     const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::switchWaitingOrHoldingAndActiveResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::switchWaitingOrHoldingAndActiveResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::conferenceResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::rejectCallResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getLastCallFailCauseResponse(
-    const RadioResponseInfo& info,
-    const LastCallFailCauseInfo& /*failCauseInfo*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    const RadioResponseInfo& info, const LastCallFailCauseInfo& /*failCauseInfo*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getSignalStrengthResponse(
-    const RadioResponseInfo& info, const SignalStrength& /*sig_strength*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getSignalStrengthResponse(const RadioResponseInfo& info,
+                                                      const SignalStrength& /*sig_strength*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getVoiceRegistrationStateResponse(
-    const RadioResponseInfo& info,
-    const VoiceRegStateResult& /*voiceRegResponse*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    const RadioResponseInfo& info, const VoiceRegStateResult& /*voiceRegResponse*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getDataRegistrationStateResponse(
-    const RadioResponseInfo& info,
-    const DataRegStateResult& /*dataRegResponse*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    const RadioResponseInfo& info, const DataRegStateResult& /*dataRegResponse*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getOperatorResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_string& /*longName*/,
+    const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*longName*/,
     const ::android::hardware::hidl_string& /*shortName*/,
     const ::android::hardware::hidl_string& /*numeric*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setRadioPowerResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setRadioPowerResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::sendDtmfResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::sendSmsResponse(const RadioResponseInfo& info,
                                             const SendSmsResult& sms) {
-  rspInfo = info;
-  sendSmsResult = sms;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    sendSmsResult = sms;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::sendSMSExpectMoreResponse(
-    const RadioResponseInfo& info, const SendSmsResult& sms) {
-  rspInfo = info;
-  sendSmsResult = sms;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::sendSMSExpectMoreResponse(const RadioResponseInfo& info,
+                                                      const SendSmsResult& sms) {
+    rspInfo = info;
+    sendSmsResult = sms;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setupDataCallResponse(
-    const RadioResponseInfo& info, const SetupDataCallResult& /*dcResponse*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setupDataCallResponse(const RadioResponseInfo& info,
+                                                  const SetupDataCallResult& /*dcResponse*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::iccIOForAppResponse(const RadioResponseInfo& info,
                                                 const IccIoResult& iccIo) {
-  rspInfo = info;
-  this->iccIoResult = iccIo;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    this->iccIoResult = iccIo;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::sendUssdResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::cancelPendingUssdResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::cancelPendingUssdResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getClirResponse(const RadioResponseInfo& info,
-                                            int32_t /*n*/, int32_t /*m*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getClirResponse(const RadioResponseInfo& info, int32_t /*n*/,
+                                            int32_t /*m*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::setClirResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getCallForwardStatusResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_vec<CallForwardInfo>&
+    const RadioResponseInfo& info, const ::android::hardware::hidl_vec<CallForwardInfo>&
     /*callForwardInfos*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setCallForwardResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setCallForwardResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getCallWaitingResponse(
-    const RadioResponseInfo& info, bool /*enable*/, int32_t /*serviceClass*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getCallWaitingResponse(const RadioResponseInfo& info, bool /*enable*/,
+                                                   int32_t /*serviceClass*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setCallWaitingResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setCallWaitingResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::acknowledgeLastIncomingGsmSmsResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::acknowledgeLastIncomingGsmSmsResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::acceptCallResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::deactivateDataCallResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::deactivateDataCallResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getFacilityLockForAppResponse(
-    const RadioResponseInfo& info, int32_t /*response*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getFacilityLockForAppResponse(const RadioResponseInfo& info,
+                                                          int32_t /*response*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setFacilityLockForAppResponse(
-    const RadioResponseInfo& info, int32_t /*retry*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setFacilityLockForAppResponse(const RadioResponseInfo& info,
+                                                          int32_t /*retry*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setBarringPasswordResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setBarringPasswordResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getNetworkSelectionModeResponse(
-    const RadioResponseInfo& info, bool /*manual*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getNetworkSelectionModeResponse(const RadioResponseInfo& info,
+                                                            bool /*manual*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::setNetworkSelectionModeAutomaticResponse(
     const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setNetworkSelectionModeManualResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setNetworkSelectionModeManualResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getAvailableNetworksResponse(
     const RadioResponseInfo& info,
     const ::android::hardware::hidl_vec<OperatorInfo>& /*networkInfos*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::startDtmfResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::stopDtmfResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getBasebandVersionResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_string& /*version*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*version*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::separateConnectionResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::separateConnectionResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::setMuteResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getMuteResponse(const RadioResponseInfo& info,
-                                            bool /*enable*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getMuteResponse(const RadioResponseInfo& info, bool /*enable*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getClipResponse(const RadioResponseInfo& info,
-                                            ClipStatus /*status*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getClipResponse(const RadioResponseInfo& info, ClipStatus /*status*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getDataCallListResponse(
     const RadioResponseInfo& info,
     const ::android::hardware::hidl_vec<SetupDataCallResult>& /*dcResponse*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::sendOemRilRequestRawResponse(
-    const RadioResponseInfo& /*info*/,
-    const ::android::hardware::hidl_vec<uint8_t>& /*data*/) {
-  return Void();
+    const RadioResponseInfo& /*info*/, const ::android::hardware::hidl_vec<uint8_t>& /*data*/) {
+    return Void();
 }
 
 Return<void> RadioResponse::sendOemRilRequestStringsResponse(
     const RadioResponseInfo& /*info*/,
-    const ::android::hardware::hidl_vec<
-        ::android::hardware::hidl_string>& /*data*/) {
-  return Void();
+    const ::android::hardware::hidl_vec< ::android::hardware::hidl_string>& /*data*/) {
+    return Void();
 }
 
-Return<void> RadioResponse::setSuppServiceNotificationsResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setSuppServiceNotificationsResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::writeSmsToSimResponse(const RadioResponseInfo& info,
-                                                  int32_t index) {
-  rspInfo = info;
-  writeSmsToSimIndex = index;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::writeSmsToSimResponse(const RadioResponseInfo& info, int32_t index) {
+    rspInfo = info;
+    writeSmsToSimIndex = index;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::deleteSmsOnSimResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::deleteSmsOnSimResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::setBandModeResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getAvailableBandModesResponse(
     const RadioResponseInfo& info,
     const ::android::hardware::hidl_vec<RadioBandMode>& /*bandModes*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::sendEnvelopeResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_string& /*commandResponse*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*commandResponse*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::sendTerminalResponseToSimResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::sendTerminalResponseToSimResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::handleStkCallSetupRequestFromSimResponse(
     const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::explicitCallTransferResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::explicitCallTransferResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setPreferredNetworkTypeResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setPreferredNetworkTypeResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getPreferredNetworkTypeResponse(
-    const RadioResponseInfo& info, PreferredNetworkType /*nw_type*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getPreferredNetworkTypeResponse(const RadioResponseInfo& info,
+                                                            PreferredNetworkType /*nw_type*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getNeighboringCidsResponse(
     const RadioResponseInfo& info,
     const ::android::hardware::hidl_vec<NeighboringCell>& /*cells*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setLocationUpdatesResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setLocationUpdatesResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setCdmaSubscriptionSourceResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setCdmaSubscriptionSourceResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setCdmaRoamingPreferenceResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setCdmaRoamingPreferenceResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getCdmaRoamingPreferenceResponse(
-    const RadioResponseInfo& info, CdmaRoamingType /*type*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getCdmaRoamingPreferenceResponse(const RadioResponseInfo& info,
+                                                             CdmaRoamingType /*type*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::setTTYModeResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getTTYModeResponse(const RadioResponseInfo& info,
-                                               TtyMode /*mode*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getTTYModeResponse(const RadioResponseInfo& info, TtyMode /*mode*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setPreferredVoicePrivacyResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setPreferredVoicePrivacyResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getPreferredVoicePrivacyResponse(
-    const RadioResponseInfo& info, bool /*enable*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getPreferredVoicePrivacyResponse(const RadioResponseInfo& info,
+                                                             bool /*enable*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::sendCDMAFeatureCodeResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::sendCDMAFeatureCodeResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::sendBurstDtmfResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::sendBurstDtmfResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::sendCdmaSmsResponse(const RadioResponseInfo& info,
                                                 const SendSmsResult& sms) {
-  rspInfo = info;
-  sendSmsResult = sms;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    sendSmsResult = sms;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::acknowledgeLastIncomingCdmaSmsResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::acknowledgeLastIncomingCdmaSmsResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getGsmBroadcastConfigResponse(
     const RadioResponseInfo& info,
-    const ::android::hardware::hidl_vec<
-        GsmBroadcastSmsConfigInfo>& /*configs*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    const ::android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>& /*configs*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setGsmBroadcastConfigResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setGsmBroadcastConfigResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setGsmBroadcastActivationResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setGsmBroadcastActivationResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getCdmaBroadcastConfigResponse(
     const RadioResponseInfo& info,
-    const ::android::hardware::hidl_vec<
-        CdmaBroadcastSmsConfigInfo>& /*configs*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    const ::android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>& /*configs*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setCdmaBroadcastConfigResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setCdmaBroadcastConfigResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setCdmaBroadcastActivationResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setCdmaBroadcastActivationResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getCDMASubscriptionResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_string& /*mdn*/,
+    const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*mdn*/,
     const ::android::hardware::hidl_string& /*hSid*/,
     const ::android::hardware::hidl_string& /*hNid*/,
     const ::android::hardware::hidl_string& /*min*/,
     const ::android::hardware::hidl_string& /*prl*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::writeSmsToRuimResponse(
-    const RadioResponseInfo& info, uint32_t index) {
-  rspInfo = info;
-  writeSmsToRuimIndex = index;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::writeSmsToRuimResponse(const RadioResponseInfo& info, uint32_t index) {
+    rspInfo = info;
+    writeSmsToRuimIndex = index;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::deleteSmsOnRuimResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::deleteSmsOnRuimResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getDeviceIdentityResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_string& /*imei*/,
+    const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*imei*/,
     const ::android::hardware::hidl_string& /*imeisv*/,
     const ::android::hardware::hidl_string& /*esn*/,
     const ::android::hardware::hidl_string& /*meid*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::exitEmergencyCallbackModeResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::exitEmergencyCallbackModeResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getSmscAddressResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_string& smsc) {
-  rspInfo = info;
-  smscAddress = smsc;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getSmscAddressResponse(const RadioResponseInfo& info,
+                                                   const ::android::hardware::hidl_string& smsc) {
+    rspInfo = info;
+    smscAddress = smsc;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setSmscAddressResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setSmscAddressResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::reportSmsMemoryStatusResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::reportSmsMemoryStatusResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::reportStkServiceIsRunningResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::reportStkServiceIsRunningResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getCdmaSubscriptionSourceResponse(
-    const RadioResponseInfo& info, CdmaSubscriptionSource /*source*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getCdmaSubscriptionSourceResponse(const RadioResponseInfo& info,
+                                                              CdmaSubscriptionSource /*source*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::requestIsimAuthenticationResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_string& /*response*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*response*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::acknowledgeIncomingGsmSmsWithPduResponse(
     const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::sendEnvelopeWithStatusResponse(
-    const RadioResponseInfo& info, const IccIoResult& /*iccIo*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::sendEnvelopeWithStatusResponse(const RadioResponseInfo& info,
+                                                           const IccIoResult& /*iccIo*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getVoiceRadioTechnologyResponse(
-    const RadioResponseInfo& info, RadioTechnology /*rat*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getVoiceRadioTechnologyResponse(const RadioResponseInfo& info,
+                                                            RadioTechnology /*rat*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getCellInfoListResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_vec<CellInfo>& /*cellInfo*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    const RadioResponseInfo& info, const ::android::hardware::hidl_vec<CellInfo>& /*cellInfo*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setCellInfoListRateResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setCellInfoListRateResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setInitialAttachApnResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setInitialAttachApnResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getImsRegistrationStateResponse(
-    const RadioResponseInfo& info, bool /*isRegistered*/,
-    RadioTechnologyFamily /*ratFamily*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getImsRegistrationStateResponse(const RadioResponseInfo& info,
+                                                            bool /*isRegistered*/,
+                                                            RadioTechnologyFamily /*ratFamily*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::sendImsSmsResponse(const RadioResponseInfo& info,
                                                const SendSmsResult& sms) {
-  rspInfo = info;
-  sendSmsResult = sms;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    sendSmsResult = sms;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::iccTransmitApduBasicChannelResponse(
-    const RadioResponseInfo& info, const IccIoResult& result) {
-  rspInfo = info;
-  this->iccIoResult = result;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::iccTransmitApduBasicChannelResponse(const RadioResponseInfo& info,
+                                                                const IccIoResult& result) {
+    rspInfo = info;
+    this->iccIoResult = result;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::iccOpenLogicalChannelResponse(
     const RadioResponseInfo& info, int32_t channelId,
     const ::android::hardware::hidl_vec<int8_t>& /*selectResponse*/) {
-  rspInfo = info;
-  this->channelId = channelId;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    this->channelId = channelId;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::iccCloseLogicalChannelResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::iccCloseLogicalChannelResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::iccTransmitApduLogicalChannelResponse(
-    const RadioResponseInfo& info, const IccIoResult& result) {
-  rspInfo = info;
-  this->iccIoResult = result;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::iccTransmitApduLogicalChannelResponse(const RadioResponseInfo& info,
+                                                                  const IccIoResult& result) {
+    rspInfo = info;
+    this->iccIoResult = result;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::nvReadItemResponse(
-    const RadioResponseInfo& info,
-    const ::android::hardware::hidl_string& /*result*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::nvReadItemResponse(const RadioResponseInfo& info,
+                                               const ::android::hardware::hidl_string& /*result*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::nvWriteItemResponse(const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::nvWriteCdmaPrlResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::nvWriteCdmaPrlResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::nvResetConfigResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::nvResetConfigResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setUiccSubscriptionResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setUiccSubscriptionResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setDataAllowedResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setDataAllowedResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getHardwareConfigResponse(
     const RadioResponseInfo& info,
     const ::android::hardware::hidl_vec<HardwareConfig>& /*config*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::requestIccSimAuthenticationResponse(
-    const RadioResponseInfo& info, const IccIoResult& result) {
-  rspInfo = info;
-  this->iccIoResult = result;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::requestIccSimAuthenticationResponse(const RadioResponseInfo& info,
+                                                                const IccIoResult& result) {
+    rspInfo = info;
+    this->iccIoResult = result;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setDataProfileResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setDataProfileResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::requestShutdownResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::requestShutdownResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getRadioCapabilityResponse(
-    const RadioResponseInfo& info, const RadioCapability& /*rc*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getRadioCapabilityResponse(const RadioResponseInfo& info,
+                                                       const RadioCapability& /*rc*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setRadioCapabilityResponse(
-    const RadioResponseInfo& info, const RadioCapability& /*rc*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setRadioCapabilityResponse(const RadioResponseInfo& info,
+                                                       const RadioCapability& /*rc*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::startLceServiceResponse(
-    const RadioResponseInfo& info, const LceStatusInfo& /*statusInfo*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::startLceServiceResponse(const RadioResponseInfo& info,
+                                                    const LceStatusInfo& /*statusInfo*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::stopLceServiceResponse(
-    const RadioResponseInfo& info, const LceStatusInfo& /*statusInfo*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::stopLceServiceResponse(const RadioResponseInfo& info,
+                                                   const LceStatusInfo& /*statusInfo*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::pullLceDataResponse(
-    const RadioResponseInfo& info, const LceDataInfo& /*lceInfo*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::pullLceDataResponse(const RadioResponseInfo& info,
+                                                const LceDataInfo& /*lceInfo*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::getModemActivityInfoResponse(
     const RadioResponseInfo& info, const ActivityStatsInfo& /*activityInfo*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setAllowedCarriersResponse(
-    const RadioResponseInfo& info, int32_t /*numAllowed*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setAllowedCarriersResponse(const RadioResponseInfo& info,
+                                                       int32_t /*numAllowed*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::getAllowedCarriersResponse(
-    const RadioResponseInfo& info, bool /*allAllowed*/,
-    const CarrierRestrictions& /*carriers*/) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::getAllowedCarriersResponse(const RadioResponseInfo& info,
+                                                       bool /*allAllowed*/,
+                                                       const CarrierRestrictions& /*carriers*/) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::sendDeviceStateResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::sendDeviceStateResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setIndicationFilterResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setIndicationFilterResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
-Return<void> RadioResponse::setSimCardPowerResponse(
-    const RadioResponseInfo& info) {
-  rspInfo = info;
-  parent.notify();
-  return Void();
+Return<void> RadioResponse::setSimCardPowerResponse(const RadioResponseInfo& info) {
+    rspInfo = info;
+    parent.notify();
+    return Void();
 }
 
 Return<void> RadioResponse::acknowledgeRequest(int32_t /*serial*/) {
-  return Void();
+    return Void();
 }
diff --git a/radio/1.0/vts/functional/sap_callback.cpp b/radio/1.0/vts/functional/sap_callback.cpp
index 3a06ecd..fdcc15c 100644
--- a/radio/1.0/vts/functional/sap_callback.cpp
+++ b/radio/1.0/vts/functional/sap_callback.cpp
@@ -18,78 +18,74 @@
 
 SapCallback::SapCallback(SapHidlTest& parent) : parent(parent) {}
 
-Return<void> SapCallback::connectResponse(int32_t token,
-                                          SapConnectRsp /*sapConnectRsp*/,
+Return<void> SapCallback::connectResponse(int32_t token, SapConnectRsp /*sapConnectRsp*/,
                                           int32_t /*maxMsgSize*/) {
-  sapResponseToken = token;
-  parent.notify();
-  return Void();
+    sapResponseToken = token;
+    parent.notify();
+    return Void();
 }
 
 Return<void> SapCallback::disconnectResponse(int32_t token) {
-  sapResponseToken = token;
-  parent.notify();
-  return Void();
+    sapResponseToken = token;
+    parent.notify();
+    return Void();
 }
 
-Return<void> SapCallback::disconnectIndication(
-    int32_t /*token*/, SapDisconnectType /*disconnectType*/) {
-  return Void();
+Return<void> SapCallback::disconnectIndication(int32_t /*token*/,
+                                               SapDisconnectType /*disconnectType*/) {
+    return Void();
 }
 
-Return<void> SapCallback::apduResponse(
-    int32_t token, SapResultCode resultCode,
-    const ::android::hardware::hidl_vec<uint8_t>& /*apduRsp*/) {
-  sapResponseToken = token;
-  sapResultCode = resultCode;
-  parent.notify();
-  return Void();
+Return<void> SapCallback::apduResponse(int32_t token, SapResultCode resultCode,
+                                       const ::android::hardware::hidl_vec<uint8_t>& /*apduRsp*/) {
+    sapResponseToken = token;
+    sapResultCode = resultCode;
+    parent.notify();
+    return Void();
 }
 
 Return<void> SapCallback::transferAtrResponse(
     int32_t token, SapResultCode resultCode,
     const ::android::hardware::hidl_vec<uint8_t>& /*atr*/) {
-  sapResponseToken = token;
-  sapResultCode = resultCode;
-  parent.notify();
-  return Void();
+    sapResponseToken = token;
+    sapResultCode = resultCode;
+    parent.notify();
+    return Void();
 }
 
-Return<void> SapCallback::powerResponse(int32_t token,
-                                        SapResultCode resultCode) {
-  sapResponseToken = token;
-  sapResultCode = resultCode;
-  parent.notify();
-  return Void();
+Return<void> SapCallback::powerResponse(int32_t token, SapResultCode resultCode) {
+    sapResponseToken = token;
+    sapResultCode = resultCode;
+    parent.notify();
+    return Void();
 }
 
-Return<void> SapCallback::resetSimResponse(int32_t token,
-                                           SapResultCode resultCode) {
-  sapResponseToken = token;
-  sapResultCode = resultCode;
-  parent.notify();
-  return Void();
+Return<void> SapCallback::resetSimResponse(int32_t token, SapResultCode resultCode) {
+    sapResponseToken = token;
+    sapResultCode = resultCode;
+    parent.notify();
+    return Void();
 }
 
-Return<void> SapCallback::statusIndication(int32_t /*token*/,
-                                           SapStatus /*status*/) {
-  return Void();
+Return<void> SapCallback::statusIndication(int32_t /*token*/, SapStatus /*status*/) {
+    return Void();
 }
 
-Return<void> SapCallback::transferCardReaderStatusResponse(
-    int32_t token, SapResultCode resultCode, int32_t /*cardReaderStatus*/) {
-  sapResponseToken = token;
-  sapResultCode = resultCode;
-  parent.notify();
-  return Void();
+Return<void> SapCallback::transferCardReaderStatusResponse(int32_t token, SapResultCode resultCode,
+                                                           int32_t /*cardReaderStatus*/) {
+    sapResponseToken = token;
+    sapResultCode = resultCode;
+    parent.notify();
+    return Void();
 }
 
-Return<void> SapCallback::errorResponse(int32_t /*token*/) { return Void(); }
+Return<void> SapCallback::errorResponse(int32_t /*token*/) {
+    return Void();
+}
 
-Return<void> SapCallback::transferProtocolResponse(int32_t token,
-                                                   SapResultCode resultCode) {
-  sapResponseToken = token;
-  sapResultCode = resultCode;
-  parent.notify();
-  return Void();
+Return<void> SapCallback::transferProtocolResponse(int32_t token, SapResultCode resultCode) {
+    sapResponseToken = token;
+    sapResultCode = resultCode;
+    parent.notify();
+    return Void();
 }
diff --git a/radio/1.0/vts/functional/sap_hidl_hal_api.cpp b/radio/1.0/vts/functional/sap_hidl_hal_api.cpp
index 3ac891d..bb61487 100644
--- a/radio/1.0/vts/functional/sap_hidl_hal_api.cpp
+++ b/radio/1.0/vts/functional/sap_hidl_hal_api.cpp
@@ -20,117 +20,117 @@
  * Test ISap.connectReq() for the response returned.
  */
 TEST_F(SapHidlTest, connectReq) {
-  int32_t token = 0;
-  int32_t maxMsgSize = 100;
+    int32_t token = GetRandomSerialNumber();
+    int32_t maxMsgSize = 100;
 
-  sap->connectReq(++token, maxMsgSize);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(sapCb->sapResponseToken, token);
+    sap->connectReq(token, maxMsgSize);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(sapCb->sapResponseToken, token);
 }
 
 /*
  * Test IRadio.disconnectReq() for the response returned
  */
 TEST_F(SapHidlTest, disconnectReq) {
-  int32_t token = 0;
+    int32_t token = GetRandomSerialNumber();
 
-  sap->disconnectReq(++token);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(sapCb->sapResponseToken, token);
+    sap->disconnectReq(token);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(sapCb->sapResponseToken, token);
 }
 
 /*
  * Test IRadio.apduReq() for the response returned.
  */
 TEST_F(SapHidlTest, apduReq) {
-  int32_t token = 0;
-  SapApduType sapApduType = SapApduType::APDU;
-  android::hardware::hidl_vec<uint8_t> command = {};
+    int32_t token = GetRandomSerialNumber();
+    SapApduType sapApduType = SapApduType::APDU;
+    android::hardware::hidl_vec<uint8_t> command = {};
 
-  sap->apduReq(++token, sapApduType, command);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(sapCb->sapResponseToken, token);
+    sap->apduReq(token, sapApduType, command);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(sapCb->sapResponseToken, token);
 
-  ASSERT_TRUE(SapResultCode::GENERIC_FAILURE == sapCb->sapResultCode ||
-              SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
-              SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
-              SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
+    ASSERT_TRUE(SapResultCode::GENERIC_FAILURE == sapCb->sapResultCode ||
+                SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
+                SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
+                SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
 }
 
 /*
  * Test IRadio.transferAtrReq() for the response returned.
  */
 TEST_F(SapHidlTest, transferAtrReq) {
-  int32_t token = 0;
+    int32_t token = GetRandomSerialNumber();
 
-  sap->transferAtrReq(++token);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(sapCb->sapResponseToken, token);
+    sap->transferAtrReq(token);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(sapCb->sapResponseToken, token);
 
-  ASSERT_TRUE(SapResultCode::GENERIC_FAILURE == sapCb->sapResultCode ||
-              SapResultCode::DATA_NOT_AVAILABLE == sapCb->sapResultCode ||
-              SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
-              SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
+    ASSERT_TRUE(SapResultCode::GENERIC_FAILURE == sapCb->sapResultCode ||
+                SapResultCode::DATA_NOT_AVAILABLE == sapCb->sapResultCode ||
+                SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
+                SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
 }
 
 /*
  * Test IRadio.powerReq() for the response returned.
  */
 TEST_F(SapHidlTest, powerReq) {
-  int32_t token = 0;
-  bool state = true;
+    int32_t token = GetRandomSerialNumber();
+    bool state = true;
 
-  sap->powerReq(++token, state);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(sapCb->sapResponseToken, token);
+    sap->powerReq(token, state);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(sapCb->sapResponseToken, token);
 
-  ASSERT_TRUE(SapResultCode::GENERIC_FAILURE == sapCb->sapResultCode ||
-              SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
-              SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
-              SapResultCode::CARD_REMOVED == sapCb->sapResultCode ||
-              SapResultCode::CARD_ALREADY_POWERED_ON == sapCb->sapResultCode);
+    ASSERT_TRUE(SapResultCode::GENERIC_FAILURE == sapCb->sapResultCode ||
+                SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
+                SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
+                SapResultCode::CARD_REMOVED == sapCb->sapResultCode ||
+                SapResultCode::CARD_ALREADY_POWERED_ON == sapCb->sapResultCode);
 }
 
 /*
  * Test IRadio.resetSimReq() for the response returned.
  */
 TEST_F(SapHidlTest, resetSimReq) {
-  int32_t token = 0;
+    int32_t token = GetRandomSerialNumber();
 
-  sap->resetSimReq(++token);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(sapCb->sapResponseToken, token);
+    sap->resetSimReq(token);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(sapCb->sapResponseToken, token);
 
-  ASSERT_TRUE(SapResultCode::GENERIC_FAILURE == sapCb->sapResultCode ||
-              SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
-              SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
-              SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
+    ASSERT_TRUE(SapResultCode::GENERIC_FAILURE == sapCb->sapResultCode ||
+                SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
+                SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
+                SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
 }
 
 /*
  * Test IRadio.transferCardReaderStatusReq() for the response returned.
  */
 TEST_F(SapHidlTest, transferCardReaderStatusReq) {
-  int32_t token = 0;
+    int32_t token = GetRandomSerialNumber();
 
-  sap->transferCardReaderStatusReq(++token);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(sapCb->sapResponseToken, token);
+    sap->transferCardReaderStatusReq(token);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(sapCb->sapResponseToken, token);
 
-  ASSERT_TRUE(SapResultCode::GENERIC_FAILURE == sapCb->sapResultCode ||
-              SapResultCode::DATA_NOT_AVAILABLE == sapCb->sapResultCode);
+    ASSERT_TRUE(SapResultCode::GENERIC_FAILURE == sapCb->sapResultCode ||
+                SapResultCode::DATA_NOT_AVAILABLE == sapCb->sapResultCode);
 }
 
 /*
  * Test IRadio.setTransferProtocolReq() for the response returned.
  */
 TEST_F(SapHidlTest, setTransferProtocolReq) {
-  int32_t token = 0;
-  SapTransferProtocol sapTransferProtocol = SapTransferProtocol::T0;
+    int32_t token = GetRandomSerialNumber();
+    SapTransferProtocol sapTransferProtocol = SapTransferProtocol::T0;
 
-  sap->setTransferProtocolReq(++token, sapTransferProtocol);
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(sapCb->sapResponseToken, token);
+    sap->setTransferProtocolReq(token, sapTransferProtocol);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(sapCb->sapResponseToken, token);
 
-  EXPECT_EQ(SapResultCode::NOT_SUPPORTED, sapCb->sapResultCode);
+    EXPECT_EQ(SapResultCode::NOT_SUPPORTED, sapCb->sapResultCode);
 }
diff --git a/radio/1.0/vts/functional/sap_hidl_hal_test.cpp b/radio/1.0/vts/functional/sap_hidl_hal_test.cpp
index 02accef..fc8cb2a 100644
--- a/radio/1.0/vts/functional/sap_hidl_hal_test.cpp
+++ b/radio/1.0/vts/functional/sap_hidl_hal_test.cpp
@@ -17,37 +17,36 @@
 #include <sap_hidl_hal_utils.h>
 
 void SapHidlTest::SetUp() {
-  sap = ::testing::VtsHalHidlTargetTestBase::getService<ISap>(
-      hidl_string(SAP_SERVICE_NAME));
-  ASSERT_NE(sap, nullptr);
+    sap = ::testing::VtsHalHidlTargetTestBase::getService<ISap>(hidl_string(SAP_SERVICE_NAME));
+    ASSERT_NE(sap, nullptr);
 
-  sapCb = new SapCallback(*this);
-  ASSERT_NE(sapCb, nullptr);
+    sapCb = new SapCallback(*this);
+    ASSERT_NE(sapCb, nullptr);
 
-  count = 0;
+    count = 0;
 
-  sap->setCallback(sapCb);
+    sap->setCallback(sapCb);
 }
 
 void SapHidlTest::TearDown() {}
 
 void SapHidlTest::notify() {
-  std::unique_lock<std::mutex> lock(mtx);
-  count++;
-  cv.notify_one();
+    std::unique_lock<std::mutex> lock(mtx);
+    count++;
+    cv.notify_one();
 }
 
 std::cv_status SapHidlTest::wait() {
-  std::unique_lock<std::mutex> lock(mtx);
+    std::unique_lock<std::mutex> lock(mtx);
 
-  std::cv_status status = std::cv_status::no_timeout;
-  auto now = std::chrono::system_clock::now();
-  while (count == 0) {
-    status = cv.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
-    if (status == std::cv_status::timeout) {
-      return status;
+    std::cv_status status = std::cv_status::no_timeout;
+    auto now = std::chrono::system_clock::now();
+    while (count == 0) {
+        status = cv.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
+        if (status == std::cv_status::timeout) {
+            return status;
+        }
     }
-  }
-  count--;
-  return status;
-}
+    count--;
+    return status;
+}
\ No newline at end of file
diff --git a/radio/1.0/vts/functional/sap_hidl_hal_utils.h b/radio/1.0/vts/functional/sap_hidl_hal_utils.h
index 38fb003..fe93a4d 100644
--- a/radio/1.0/vts/functional/sap_hidl_hal_utils.h
+++ b/radio/1.0/vts/functional/sap_hidl_hal_utils.h
@@ -25,6 +25,8 @@
 #include <android/hardware/radio/1.0/ISapCallback.h>
 #include <android/hardware/radio/1.0/types.h>
 
+#include <vts_test_util.h>
+
 using namespace ::android::hardware::radio::V1_0;
 
 using ::android::hardware::hidl_string;
@@ -40,77 +42,71 @@
 
 /* Callback class for sap response */
 class SapCallback : public ISapCallback {
- private:
-  SapHidlTest& parent;
+   private:
+    SapHidlTest& parent;
 
- public:
-  SapResultCode sapResultCode;
-  int32_t sapResponseToken;
+   public:
+    SapResultCode sapResultCode;
+    int32_t sapResponseToken;
 
-  SapCallback(SapHidlTest& parent);
+    SapCallback(SapHidlTest& parent);
 
-  virtual ~SapCallback() = default;
+    virtual ~SapCallback() = default;
 
-  Return<void> connectResponse(int32_t token, SapConnectRsp sapConnectRsp,
-                               int32_t maxMsgSize);
+    Return<void> connectResponse(int32_t token, SapConnectRsp sapConnectRsp, int32_t maxMsgSize);
 
-  Return<void> disconnectResponse(int32_t token);
+    Return<void> disconnectResponse(int32_t token);
 
-  Return<void> disconnectIndication(int32_t token,
-                                    SapDisconnectType disconnectType);
+    Return<void> disconnectIndication(int32_t token, SapDisconnectType disconnectType);
 
-  Return<void> apduResponse(
-      int32_t token, SapResultCode resultCode,
-      const ::android::hardware::hidl_vec<uint8_t>& apduRsp);
+    Return<void> apduResponse(int32_t token, SapResultCode resultCode,
+                              const ::android::hardware::hidl_vec<uint8_t>& apduRsp);
 
-  Return<void> transferAtrResponse(
-      int32_t token, SapResultCode resultCode,
-      const ::android::hardware::hidl_vec<uint8_t>& atr);
+    Return<void> transferAtrResponse(int32_t token, SapResultCode resultCode,
+                                     const ::android::hardware::hidl_vec<uint8_t>& atr);
 
-  Return<void> powerResponse(int32_t token, SapResultCode resultCode);
+    Return<void> powerResponse(int32_t token, SapResultCode resultCode);
 
-  Return<void> resetSimResponse(int32_t token, SapResultCode resultCode);
+    Return<void> resetSimResponse(int32_t token, SapResultCode resultCode);
 
-  Return<void> statusIndication(int32_t token, SapStatus status);
+    Return<void> statusIndication(int32_t token, SapStatus status);
 
-  Return<void> transferCardReaderStatusResponse(int32_t token,
-                                                SapResultCode resultCode,
-                                                int32_t cardReaderStatus);
+    Return<void> transferCardReaderStatusResponse(int32_t token, SapResultCode resultCode,
+                                                  int32_t cardReaderStatus);
 
-  Return<void> errorResponse(int32_t token);
+    Return<void> errorResponse(int32_t token);
 
-  Return<void> transferProtocolResponse(int32_t token,
-                                        SapResultCode resultCode);
+    Return<void> transferProtocolResponse(int32_t token, SapResultCode resultCode);
 };
 
 // The main test class for Sap HIDL.
 class SapHidlTest : public ::testing::VtsHalHidlTargetTestBase {
- private:
-  std::mutex mtx;
-  std::condition_variable cv;
-  int count;
+   private:
+    std::mutex mtx;
+    std::condition_variable cv;
+    int count;
 
- public:
-  virtual void SetUp() override;
+   public:
+    virtual void SetUp() override;
 
-  virtual void TearDown() override;
+    virtual void TearDown() override;
 
-  /* Used as a mechanism to inform the test about data/event callback */
-  void notify();
+    /* Used as a mechanism to inform the test about data/event callback */
+    void notify();
 
-  /* Test code calls this function to wait for response */
-  std::cv_status wait();
+    /* Test code calls this function to wait for response */
+    std::cv_status wait();
 
-  /* Sap service */
-  sp<ISap> sap;
+    /* Sap service */
+    sp<ISap> sap;
 
-  /* Sap Callback object */
-  sp<SapCallback> sapCb;
+    /* Sap Callback object */
+    sp<SapCallback> sapCb;
 };
 
 // A class for test environment setup
 class SapHidlEnvironment : public ::testing::Environment {
- public:
-  virtual void SetUp() {}
-  virtual void TearDown() {}
+   public:
+    virtual void SetUp() {}
+    virtual void TearDown() {}
 };
diff --git a/radio/1.0/vts/functional/vts_test_util.cpp b/radio/1.0/vts/functional/vts_test_util.cpp
new file mode 100644
index 0000000..c6d1f9f
--- /dev/null
+++ b/radio/1.0/vts/functional/vts_test_util.cpp
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <vts_test_util.h>
+#include <iostream>
+using namespace std;
+
+int GetRandomSerialNumber() {
+    return rand();
+}
\ No newline at end of file
diff --git a/radio/1.0/vts/functional/vts_test_util.h b/radio/1.0/vts/functional/vts_test_util.h
new file mode 100644
index 0000000..939013f
--- /dev/null
+++ b/radio/1.0/vts/functional/vts_test_util.h
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+int GetRandomSerialNumber();
\ No newline at end of file
diff --git a/renderscript/1.0/default/Android.bp b/renderscript/1.0/default/Android.bp
index 29b781e..823603a 100644
--- a/renderscript/1.0/default/Android.bp
+++ b/renderscript/1.0/default/Android.bp
@@ -19,4 +19,11 @@
         "android.hardware.renderscript@1.0",
         "android.hidl.base@1.0",
     ],
+
+    product_variables: {
+        override_rs_driver: {
+            cflags: ["-DOVERRIDE_RS_DRIVER=%s"],
+        },
+    },
+
 }
diff --git a/renderscript/1.0/default/Context.cpp b/renderscript/1.0/default/Context.cpp
index 389b6e7..fbfc652 100644
--- a/renderscript/1.0/default/Context.cpp
+++ b/renderscript/1.0/default/Context.cpp
@@ -16,7 +16,19 @@
     uint32_t _sdkVersion = sdkVersion;
     RsContextType _ct = static_cast<RsContextType>(ct);
     int32_t _flags = flags;
-    mContext = Device::getHal().ContextCreate(_dev, _version, _sdkVersion, _ct, _flags);
+    const char* driverName = nullptr;
+
+#ifdef OVERRIDE_RS_DRIVER
+#define XSTR(S) #S
+#define STR(S) XSTR(S)
+#define OVERRIDE_RS_DRIVER_STRING STR(OVERRIDE_RS_DRIVER)
+    static std::string driverString(OVERRIDE_RS_DRIVER_STRING);
+    driverName = driverString.c_str();
+#undef XSTR
+#undef STR
+#endif  // OVERRIDE_RS_DRIVER
+    mContext = Device::getHal().ContextCreateVendor(_dev, _version, _sdkVersion,
+                                                    _ct, _flags, driverName);
 }
 
 
diff --git a/renderscript/1.0/default/Device.cpp b/renderscript/1.0/default/Device.cpp
index 86cf8eb..3aae060 100644
--- a/renderscript/1.0/default/Device.cpp
+++ b/renderscript/1.0/default/Device.cpp
@@ -42,91 +42,150 @@
     void* handle = dlopen(filename, RTLD_LAZY | RTLD_LOCAL);
 
     dispatchTable dispatchHal = {
-        .SetNativeLibDir = (SetNativeLibDirFnPtr)nullptr,
+        .SetNativeLibDir = (SetNativeLibDirFnPtr) nullptr,
 
-        .Allocation1DData = (Allocation1DDataFnPtr)dlsym(handle, "rsAllocation1DData"),
-        .Allocation1DElementData = (Allocation1DElementDataFnPtr)nullptr,
-        .Allocation1DRead = (Allocation1DReadFnPtr)dlsym(handle, "rsAllocation1DRead"),
-        .Allocation2DData = (Allocation2DDataFnPtr)dlsym(handle, "rsAllocation2DData"),
-        .Allocation2DRead = (Allocation2DReadFnPtr)dlsym(handle, "rsAllocation2DRead"),
-        .Allocation3DData = (Allocation3DDataFnPtr)dlsym(handle, "rsAllocation3DData"),
-        .Allocation3DRead = (Allocation3DReadFnPtr)dlsym(handle, "rsAllocation3DRead"),
-        .AllocationAdapterCreate = (AllocationAdapterCreateFnPtr)dlsym(handle, "rsAllocationAdapterCreate"),
-        .AllocationAdapterOffset = (AllocationAdapterOffsetFnPtr)dlsym(handle, "rsAllocationAdapterOffset"),
-        .AllocationCopy2DRange = (AllocationCopy2DRangeFnPtr)dlsym(handle, "rsAllocationCopy2DRange"),
-        .AllocationCopy3DRange = (AllocationCopy3DRangeFnPtr)dlsym(handle, "rsAllocationCopy3DRange"),
-        .AllocationCopyToBitmap = (AllocationCopyToBitmapFnPtr)dlsym(handle, "rsAllocationCopyToBitmap"),
-        .AllocationCreateFromBitmap = (AllocationCreateFromBitmapFnPtr)dlsym(handle, "rsAllocationCreateFromBitmap"),
-        .AllocationCreateStrided = (AllocationCreateStridedFnPtr)dlsym(handle, "rsAllocationCreateStrided"),
-        .AllocationCreateTyped = (AllocationCreateTypedFnPtr)dlsym(handle, "rsAllocationCreateTyped"),
-        .AllocationCubeCreateFromBitmap = (AllocationCubeCreateFromBitmapFnPtr)dlsym(handle, "rsAllocationCubeCreateFromBitmap"),
-        .AllocationElementData = (AllocationElementDataFnPtr)dlsym(handle, "rsAllocationElementData"),
-        .AllocationElementRead = (AllocationElementReadFnPtr)dlsym(handle, "rsAllocationElementRead"),
-        .AllocationGenerateMipmaps = (AllocationGenerateMipmapsFnPtr)dlsym(handle, "rsAllocationGenerateMipmaps"),
-        .AllocationGetPointer = (AllocationGetPointerFnPtr)dlsym(handle, "rsAllocationGetPointer"),
-        .AllocationGetSurface = (AllocationGetSurfaceFnPtr)dlsym(handle, "rsAllocationGetSurface"),
-        .AllocationGetType = (AllocationGetTypeFnPtr)dlsym(handle, "rsaAllocationGetType"),
-        .AllocationIoReceive = (AllocationIoReceiveFnPtr)dlsym(handle, "rsAllocationIoReceive"),
-        .AllocationIoSend = (AllocationIoSendFnPtr)dlsym(handle, "rsAllocationIoSend"),
-        .AllocationRead = (AllocationReadFnPtr)dlsym(handle, "rsAllocationRead"),
-        .AllocationResize1D = (AllocationResize1DFnPtr)dlsym(handle, "rsAllocationResize1D"),
-        .AllocationSetSurface = (AllocationSetSurfaceFnPtr)dlsym(handle, "rsAllocationSetSurface"),
-        .AllocationSetupBufferQueue = (AllocationSetupBufferQueueFnPtr)dlsym(handle, "rsAllocationSetupBufferQueue"),
-        .AllocationShareBufferQueue = (AllocationShareBufferQueueFnPtr)dlsym(handle, "rsAllocationShareBufferQueue"),
-        .AllocationSyncAll = (AllocationSyncAllFnPtr)dlsym(handle, "rsAllocationSyncAll"),
+        .Allocation1DData =
+            (Allocation1DDataFnPtr)dlsym(handle, "rsAllocation1DData"),
+        .Allocation1DElementData = (Allocation1DElementDataFnPtr) nullptr,
+        .Allocation1DRead =
+            (Allocation1DReadFnPtr)dlsym(handle, "rsAllocation1DRead"),
+        .Allocation2DData =
+            (Allocation2DDataFnPtr)dlsym(handle, "rsAllocation2DData"),
+        .Allocation2DRead =
+            (Allocation2DReadFnPtr)dlsym(handle, "rsAllocation2DRead"),
+        .Allocation3DData =
+            (Allocation3DDataFnPtr)dlsym(handle, "rsAllocation3DData"),
+        .Allocation3DRead =
+            (Allocation3DReadFnPtr)dlsym(handle, "rsAllocation3DRead"),
+        .AllocationAdapterCreate = (AllocationAdapterCreateFnPtr)dlsym(
+            handle, "rsAllocationAdapterCreate"),
+        .AllocationAdapterOffset = (AllocationAdapterOffsetFnPtr)dlsym(
+            handle, "rsAllocationAdapterOffset"),
+        .AllocationCopy2DRange = (AllocationCopy2DRangeFnPtr)dlsym(
+            handle, "rsAllocationCopy2DRange"),
+        .AllocationCopy3DRange = (AllocationCopy3DRangeFnPtr)dlsym(
+            handle, "rsAllocationCopy3DRange"),
+        .AllocationCopyToBitmap = (AllocationCopyToBitmapFnPtr)dlsym(
+            handle, "rsAllocationCopyToBitmap"),
+        .AllocationCreateFromBitmap = (AllocationCreateFromBitmapFnPtr)dlsym(
+            handle, "rsAllocationCreateFromBitmap"),
+        .AllocationCreateStrided = (AllocationCreateStridedFnPtr)dlsym(
+            handle, "rsAllocationCreateStrided"),
+        .AllocationCreateTyped = (AllocationCreateTypedFnPtr)dlsym(
+            handle, "rsAllocationCreateTyped"),
+        .AllocationCubeCreateFromBitmap =
+            (AllocationCubeCreateFromBitmapFnPtr)dlsym(
+                handle, "rsAllocationCubeCreateFromBitmap"),
+        .AllocationElementData = (AllocationElementDataFnPtr)dlsym(
+            handle, "rsAllocationElementData"),
+        .AllocationElementRead = (AllocationElementReadFnPtr)dlsym(
+            handle, "rsAllocationElementRead"),
+        .AllocationGenerateMipmaps = (AllocationGenerateMipmapsFnPtr)dlsym(
+            handle, "rsAllocationGenerateMipmaps"),
+        .AllocationGetPointer =
+            (AllocationGetPointerFnPtr)dlsym(handle, "rsAllocationGetPointer"),
+        .AllocationGetSurface =
+            (AllocationGetSurfaceFnPtr)dlsym(handle, "rsAllocationGetSurface"),
+        .AllocationGetType =
+            (AllocationGetTypeFnPtr)dlsym(handle, "rsaAllocationGetType"),
+        .AllocationIoReceive =
+            (AllocationIoReceiveFnPtr)dlsym(handle, "rsAllocationIoReceive"),
+        .AllocationIoSend =
+            (AllocationIoSendFnPtr)dlsym(handle, "rsAllocationIoSend"),
+        .AllocationRead =
+            (AllocationReadFnPtr)dlsym(handle, "rsAllocationRead"),
+        .AllocationResize1D =
+            (AllocationResize1DFnPtr)dlsym(handle, "rsAllocationResize1D"),
+        .AllocationSetSurface =
+            (AllocationSetSurfaceFnPtr)dlsym(handle, "rsAllocationSetSurface"),
+        .AllocationSetupBufferQueue = (AllocationSetupBufferQueueFnPtr)dlsym(
+            handle, "rsAllocationSetupBufferQueue"),
+        .AllocationShareBufferQueue = (AllocationShareBufferQueueFnPtr)dlsym(
+            handle, "rsAllocationShareBufferQueue"),
+        .AllocationSyncAll =
+            (AllocationSyncAllFnPtr)dlsym(handle, "rsAllocationSyncAll"),
         .AssignName = (AssignNameFnPtr)dlsym(handle, "rsAssignName"),
         .ClosureCreate = (ClosureCreateFnPtr)dlsym(handle, "rsClosureCreate"),
         .ClosureSetArg = (ClosureSetArgFnPtr)dlsym(handle, "rsClosureSetArg"),
-        .ClosureSetGlobal = (ClosureSetGlobalFnPtr)dlsym(handle, "rsClosureSetGlobal"),
-        .ContextCreate = (ContextCreateFnPtr)dlsym(handle, "rsContextCreate"),
-        .ContextDeinitToClient = (ContextDeinitToClientFnPtr)dlsym(handle, "rsContextDeinitToClient"),
-        .ContextDestroy = (ContextDestroyFnPtr)dlsym(handle, "rsContextDestroy"),
+        .ClosureSetGlobal =
+            (ClosureSetGlobalFnPtr)dlsym(handle, "rsClosureSetGlobal"),
+        .ContextCreateVendor =
+            (ContextCreateVendorFnPtr)dlsym(handle, "rsContextCreateVendor"),
+        .ContextDeinitToClient = (ContextDeinitToClientFnPtr)dlsym(
+            handle, "rsContextDeinitToClient"),
+        .ContextDestroy =
+            (ContextDestroyFnPtr)dlsym(handle, "rsContextDestroy"),
         .ContextDump = (ContextDumpFnPtr)dlsym(handle, "rsContextDump"),
         .ContextFinish = (ContextFinishFnPtr)dlsym(handle, "rsContextFinish"),
-        .ContextGetMessage = (ContextGetMessageFnPtr)dlsym(handle, "rsContextGetMessage"),
-        .ContextInitToClient = (ContextInitToClientFnPtr)dlsym(handle, "rsContextInitToClient"),
-        .ContextPeekMessage = (ContextPeekMessageFnPtr)dlsym(handle, "rsContextPeekMessage"),
-        .ContextSendMessage = (ContextSendMessageFnPtr)dlsym(handle, "rsContextSendMessage"),
-        .ContextSetCacheDir = (ContextSetCacheDirFnPtr)dlsym(handle, "rsContextSetCacheDir"),
-        .ContextSetPriority = (ContextSetPriorityFnPtr)dlsym(handle, "rsContextSetPriority"),
-        .DeviceCreate = (DeviceCreateFnPtr)nullptr,
-        .DeviceDestroy = (DeviceDestroyFnPtr)nullptr,
-        .DeviceSetConfig = (DeviceSetConfigFnPtr)nullptr,
-        .ElementCreate2 = (ElementCreate2FnPtr)dlsym(handle, "rsElementCreate2"),
+        .ContextGetMessage =
+            (ContextGetMessageFnPtr)dlsym(handle, "rsContextGetMessage"),
+        .ContextInitToClient =
+            (ContextInitToClientFnPtr)dlsym(handle, "rsContextInitToClient"),
+        .ContextPeekMessage =
+            (ContextPeekMessageFnPtr)dlsym(handle, "rsContextPeekMessage"),
+        .ContextSendMessage =
+            (ContextSendMessageFnPtr)dlsym(handle, "rsContextSendMessage"),
+        .ContextSetCacheDir =
+            (ContextSetCacheDirFnPtr)dlsym(handle, "rsContextSetCacheDir"),
+        .ContextSetPriority =
+            (ContextSetPriorityFnPtr)dlsym(handle, "rsContextSetPriority"),
+        .DeviceCreate = (DeviceCreateFnPtr) nullptr,
+        .DeviceDestroy = (DeviceDestroyFnPtr) nullptr,
+        .DeviceSetConfig = (DeviceSetConfigFnPtr) nullptr,
+        .ElementCreate2 =
+            (ElementCreate2FnPtr)dlsym(handle, "rsElementCreate2"),
         .ElementCreate = (ElementCreateFnPtr)dlsym(handle, "rsElementCreate"),
-        .ElementGetNativeData = (ElementGetNativeDataFnPtr)dlsym(handle, "rsaElementGetNativeData"),
-        .ElementGetSubElements = (ElementGetSubElementsFnPtr)dlsym(handle, "rsaElementGetSubElements"),
+        .ElementGetNativeData =
+            (ElementGetNativeDataFnPtr)dlsym(handle, "rsaElementGetNativeData"),
+        .ElementGetSubElements = (ElementGetSubElementsFnPtr)dlsym(
+            handle, "rsaElementGetSubElements"),
         .GetName = (GetNameFnPtr)dlsym(handle, "rsaGetName"),
-        .InvokeClosureCreate = (InvokeClosureCreateFnPtr)dlsym(handle, "rsInvokeClosureCreate"),
+        .InvokeClosureCreate =
+            (InvokeClosureCreateFnPtr)dlsym(handle, "rsInvokeClosureCreate"),
         .ObjDestroy = (ObjDestroyFnPtr)dlsym(handle, "rsObjDestroy"),
         .SamplerCreate = (SamplerCreateFnPtr)dlsym(handle, "rsSamplerCreate"),
-        .ScriptBindAllocation = (ScriptBindAllocationFnPtr)dlsym(handle, "rsScriptBindAllocation"),
+        .ScriptBindAllocation =
+            (ScriptBindAllocationFnPtr)dlsym(handle, "rsScriptBindAllocation"),
         .ScriptCCreate = (ScriptCCreateFnPtr)dlsym(handle, "rsScriptCCreate"),
-        .ScriptFieldIDCreate = (ScriptFieldIDCreateFnPtr)dlsym(handle, "rsScriptFieldIDCreate"),
-        .ScriptForEach = (ScriptForEachFnPtr)nullptr,
-        .ScriptForEachMulti = (ScriptForEachMultiFnPtr)dlsym(handle, "rsScriptForEachMulti"),
+        .ScriptFieldIDCreate =
+            (ScriptFieldIDCreateFnPtr)dlsym(handle, "rsScriptFieldIDCreate"),
+        .ScriptForEach = (ScriptForEachFnPtr) nullptr,
+        .ScriptForEachMulti =
+            (ScriptForEachMultiFnPtr)dlsym(handle, "rsScriptForEachMulti"),
         .ScriptGetVarV = (ScriptGetVarVFnPtr)dlsym(handle, "rsScriptGetVarV"),
-        .ScriptGroup2Create = (ScriptGroup2CreateFnPtr)dlsym(handle, "rsScriptGroup2Create"),
-        .ScriptGroupCreate = (ScriptGroupCreateFnPtr)dlsym(handle, "rsScriptGroupCreate"),
-        .ScriptGroupExecute = (ScriptGroupExecuteFnPtr)dlsym(handle, "rsScriptGroupExecute"),
-        .ScriptGroupSetInput = (ScriptGroupSetInputFnPtr)dlsym(handle, "rsScriptGroupSetInput"),
-        .ScriptGroupSetOutput = (ScriptGroupSetOutputFnPtr)dlsym(handle, "rsScriptGroupSetOutput"),
-        .ScriptIntrinsicCreate = (ScriptIntrinsicCreateFnPtr)dlsym(handle, "rsScriptIntrinsicCreate"),
+        .ScriptGroup2Create =
+            (ScriptGroup2CreateFnPtr)dlsym(handle, "rsScriptGroup2Create"),
+        .ScriptGroupCreate =
+            (ScriptGroupCreateFnPtr)dlsym(handle, "rsScriptGroupCreate"),
+        .ScriptGroupExecute =
+            (ScriptGroupExecuteFnPtr)dlsym(handle, "rsScriptGroupExecute"),
+        .ScriptGroupSetInput =
+            (ScriptGroupSetInputFnPtr)dlsym(handle, "rsScriptGroupSetInput"),
+        .ScriptGroupSetOutput =
+            (ScriptGroupSetOutputFnPtr)dlsym(handle, "rsScriptGroupSetOutput"),
+        .ScriptIntrinsicCreate = (ScriptIntrinsicCreateFnPtr)dlsym(
+            handle, "rsScriptIntrinsicCreate"),
         .ScriptInvoke = (ScriptInvokeFnPtr)dlsym(handle, "rsScriptInvoke"),
-        .ScriptInvokeIDCreate = (ScriptInvokeIDCreateFnPtr)dlsym(handle, "rsScriptInvokeIDCreate"),
+        .ScriptInvokeIDCreate =
+            (ScriptInvokeIDCreateFnPtr)dlsym(handle, "rsScriptInvokeIDCreate"),
         .ScriptInvokeV = (ScriptInvokeVFnPtr)dlsym(handle, "rsScriptInvokeV"),
-        .ScriptKernelIDCreate = (ScriptKernelIDCreateFnPtr)dlsym(handle, "rsScriptKernelIDCreate"),
+        .ScriptKernelIDCreate =
+            (ScriptKernelIDCreateFnPtr)dlsym(handle, "rsScriptKernelIDCreate"),
         .ScriptReduce = (ScriptReduceFnPtr)dlsym(handle, "rsScriptReduce"),
-        .ScriptSetTimeZone = (ScriptSetTimeZoneFnPtr)dlsym(handle, "rsScriptSetTimeZone"),
+        .ScriptSetTimeZone =
+            (ScriptSetTimeZoneFnPtr)dlsym(handle, "rsScriptSetTimeZone"),
         .ScriptSetVarD = (ScriptSetVarDFnPtr)dlsym(handle, "rsScriptSetVarD"),
         .ScriptSetVarF = (ScriptSetVarFFnPtr)dlsym(handle, "rsScriptSetVarF"),
         .ScriptSetVarI = (ScriptSetVarIFnPtr)dlsym(handle, "rsScriptSetVarI"),
         .ScriptSetVarJ = (ScriptSetVarJFnPtr)dlsym(handle, "rsScriptSetVarJ"),
-        .ScriptSetVarObj = (ScriptSetVarObjFnPtr)dlsym(handle, "rsScriptSetVarObj"),
-        .ScriptSetVarVE = (ScriptSetVarVEFnPtr)dlsym(handle, "rsScriptSetVarVE"),
+        .ScriptSetVarObj =
+            (ScriptSetVarObjFnPtr)dlsym(handle, "rsScriptSetVarObj"),
+        .ScriptSetVarVE =
+            (ScriptSetVarVEFnPtr)dlsym(handle, "rsScriptSetVarVE"),
         .ScriptSetVarV = (ScriptSetVarVFnPtr)dlsym(handle, "rsScriptSetVarV"),
         .TypeCreate = (TypeCreateFnPtr)dlsym(handle, "rsTypeCreate"),
-        .TypeGetNativeData = (TypeGetNativeDataFnPtr)dlsym(handle, "rsaTypeGetNativeData"),
+        .TypeGetNativeData =
+            (TypeGetNativeDataFnPtr)dlsym(handle, "rsaTypeGetNativeData"),
     };
 
     return dispatchHal;