diff --git a/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp b/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp
index d01adf2..e7c89d5 100644
--- a/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp
+++ b/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-#include<radio_hidl_hal_utils.h>
+#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;
+  int status = RUN_ALL_TESTS();
+  LOG(INFO) << "Test result = " << status;
 
-    return 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 f902588..5306076 100644
--- a/radio/1.0/vts/functional/VtsHalSapV1_0TargetTest.cpp
+++ b/radio/1.0/vts/functional/VtsHalSapV1_0TargetTest.cpp
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-#include<sap_hidl_hal_utils.h>
+#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;
+  int status = RUN_ALL_TESTS();
+  LOG(INFO) << "Test result = " << status;
 
-    return 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 d87ce5f..53d1b90 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
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
 
 using namespace ::android::hardware::radio::V1_0;
 
@@ -22,153 +22,154 @@
  * Test IRadio.setGsmBroadcastConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, setGsmBroadcastConfig) {
-    int serial = 0;
+  int serial = 0;
 
-    // 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) {
-        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.getGsmBroadcastConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, getGsmBroadcastConfig) {
-    int serial = 0;
+  int serial = 0;
 
-    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) {
-        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.setCdmaBroadcastConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, setCdmaBroadcastConfig) {
-    int serial = 0;
+  int serial = 0;
 
-    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) {
-        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.getCdmaBroadcastConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, getCdmaBroadcastConfig) {
-    int serial = 0;
+  int serial = 0;
 
-    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) {
-        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.setCdmaBroadcastActivation() for the response returned.
  */
 TEST_F(RadioHidlTest, setCdmaBroadcastActivation) {
-    int serial = 0;
-    bool activate = false;
+  int serial = 0;
+  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) {
-        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.setGsmBroadcastActivation() for the response returned.
  */
 TEST_F(RadioHidlTest, setGsmBroadcastActivation) {
-    int serial = 0;
-    bool activate = false;
+  int serial = 0;
+  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) {
-        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_data.cpp b/radio/1.0/vts/functional/radio_hidl_hal_data.cpp
index 06cab6a..526cb04 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_data.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_data.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
 
 using namespace ::android::hardware::radio::V1_0;
 
@@ -22,198 +22,198 @@
  * Test IRadio.getDataRegistrationState() for the response returned.
  */
 TEST_F(RadioHidlTest, getDataRegistrationState) {
-    int serial = 0;
+  int serial = 0;
 
-    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 = 0;
 
-    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_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.deactivateDataCall() for the response returned.
  */
 TEST_F(RadioHidlTest, deactivateDataCall) {
-    int serial = 0;
-    int cid = 1;
-    bool reasonRadioShutDown = false;
+  int serial = 0;
+  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_ARGUMENTS, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.getDataCallList() for the response returned.
  */
 TEST_F(RadioHidlTest, getDataCallList) {
-    int serial = 0;
+  int serial = 0;
 
-    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) {
-        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.setInitialAttachApn() for the response returned.
  */
 TEST_F(RadioHidlTest, setInitialAttachApn) {
-    int serial = 0;
+  int serial = 0;
 
-    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_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.setDataAllowed() for the response returned.
  */
 TEST_F(RadioHidlTest, setDataAllowed) {
-    int serial = 0;
-    bool allow = true;
+  int serial = 0;
+  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 = 0;
 
-    // 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 9cae9c2..19738d5 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp
@@ -14,293 +14,307 @@
  * limitations under the License.
  */
 
- #include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
 
 /*
  * 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 = 1;
 
-    // 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 = 1;
 
-    // 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 = 1;
 
-    // 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 = 1;
 
-    // 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 = 1;
 
-    // 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 = 1;
 
-    // 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 = 1;
 
-    // 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 = 1;
 
-    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 = 1;
+  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 serial = 1;
 
-    for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
-        radio->iccOpenLogicalChannel(++serial, 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);
-    }
+  for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+    radio->iccOpenLogicalChannel(++serial, 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);
+  }
 }
 
 /*
  * 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 = 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);
 
-    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();
+  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(1, msg);
+  EXPECT_EQ(std::cv_status::no_timeout, wait());
+  EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+  EXPECT_EQ(1, 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 = 1;
 
-    // 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 = 1;
 
-    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::PASSWORD_INCORRECT);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::PASSWORD_INCORRECT);
+  }
 }
\ No newline at end of file
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 fdc39d8..0ec2e5c 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_ims.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_ims.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
 
 using namespace ::android::hardware::radio::V1_0;
 
@@ -22,179 +22,181 @@
  * Test IRadio.getClir() for the response returned.
  */
 TEST_F(RadioHidlTest, getClir) {
-    int serial = 0;
+  int serial = 0;
 
-    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(radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.setClir() for the response returned.
  */
 TEST_F(RadioHidlTest, setClir) {
-    int serial = 0;
-    int32_t status = 1;
+  int serial = 0;
+  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 = 0;
+  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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_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 = 0;
+  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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_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 = 0;
+  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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.getClip() for the response returned.
  */
 TEST_F(RadioHidlTest, getClip) {
-    int serial = 0;
+  int serial = 0;
 
-    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(radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.setSuppServiceNotifications() for the response returned.
  */
 TEST_F(RadioHidlTest, setSuppServiceNotifications) {
-    int serial = 0;
-    bool enable = false;
+  int serial = 0;
+  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 = 0;
+  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) {
-        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.getImsRegistrationState() for the response returned.
  */
 TEST_F(RadioHidlTest, getImsRegistrationState) {
-    int serial = 0;
+  int serial = 0;
 
-    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 f704520..2e0a10f 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_misc.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_misc.cpp
@@ -14,778 +14,779 @@
  * limitations under the License.
  */
 
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
 
 /*
  * Test IRadio.getSignalStrength() for the response returned.
  */
 TEST_F(RadioHidlTest, getSignalStrength) {
-    int serial = 1;
+  int serial = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME);
+  }
 }
 
 /*
  * Test IRadio.setNetworkSelectionModeManual() for the response returned.
  */
 TEST_F(RadioHidlTest, setNetworkSelectionModeManual) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME);
+  }
 }
 
 /*
  * Test IRadio.getAvailableNetworks() for the response returned.
  */
 TEST_F(RadioHidlTest, getAvailableNetworks) {
-    int serial = 1;
+  int serial = 1;
 
-    radio->getAvailableNetworks(++serial);
-    EXPECT_EQ(std::cv_status::no_timeout, wait());
-    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
-    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+  radio->getAvailableNetworks(++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.getBasebandVersion() for the response returned.
  */
 TEST_F(RadioHidlTest, getBasebandVersion) {
-    int serial = 1;
+  int serial = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::NONE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+  }
 }
 
 /*
  * Test IRadio.getTTYMode() for the response returned.
  */
 TEST_F(RadioHidlTest, getTTYMode) {
-    int serial = 1;
+  int serial = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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 = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::NONE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+  }
 }
 
 /*
  * Test IRadio.setCellInfoListRate() for the response returned.
  */
 TEST_F(RadioHidlTest, setCellInfoListRate) {
-    int serial = 1;
+  int serial = 1;
 
-    // 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 = 1;
 
-    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 = 1;
+  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 = 1;
+  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 = 1;
 
-    radio->nvResetConfig(++serial, ResetNvType::RELOAD);
-    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::RELOAD);
+  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 = 1;
+  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(radioRsp->rspInfo.error == RadioError::NONE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+  }
 }
 
 /*
  * Test IRadio.getHardwareConfig() for the response returned.
  */
 TEST_F(RadioHidlTest, getHardwareConfig) {
-    int serial = 1;
+  int serial = 1;
 
-    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 = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::NONE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+  }
 }
 
 /*
  * Test IRadio.getRadioCapability() for the response returned.
  */
 TEST_F(RadioHidlTest, getRadioCapability) {
-    int serial = 1;
+  int serial = 1;
 
-    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 = 1;
+  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(radioRsp->rspInfo.error == RadioError::NONE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+  }
 }
 
 /*
  * Test IRadio.startLceService() for the response returned.
  */
 TEST_F(RadioHidlTest, startLceService) {
-    int serial = 1;
+  int serial = 1;
 
-    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::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.stopLceService() for the response returned.
  */
 TEST_F(RadioHidlTest, stopLceService) {
-    int serial = 1;
+  int serial = 1;
 
-    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 = 1;
 
-    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::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.getModemActivityInfo() for the response returned.
  */
 TEST_F(RadioHidlTest, getModemActivityInfo) {
-    int serial = 1;
+  int serial = 1;
 
-    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;
-    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();
+  int serial = 1;
+  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();
 
-    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);
+  }
 }
 
 /*
  * Test IRadio.getAllowedCarriers() for the response returned.
  */
 TEST_F(RadioHidlTest, getAllowedCarriers) {
-    int serial = 1;
+  int serial = 1;
 
-    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 = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::NONE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+  }
 }
 
 /*
  * Test IRadio.setIndicationFilter() for the response returned.
  */
 TEST_F(RadioHidlTest, setIndicationFilter) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::NONE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+  }
 }
 
 /*
  * Test IRadio.setSimCardPower() for the response returned.
  */
 TEST_F(RadioHidlTest, setSimCardPower) {
-    int serial = 1;
+  int serial = 1;
 
-    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::SIM_ABSENT);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
+  }
 }
\ 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 54ae7c0..7caf471 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_sms.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_sms.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
 
 using namespace ::android::hardware::radio::V1_0;
 
@@ -22,403 +22,408 @@
  * Test IRadio.sendSms() for the response returned.
  */
 TEST_F(RadioHidlTest, sendSms) {
-    int serial = 0;
-    GsmSmsMessage msg;
-    msg.smscPdu = "";
-    msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
+  int serial = 0;
+  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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-        EXPECT_EQ(0, radioRsp->sendSmsResult.errorCode);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                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 = 0;
+  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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                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 = 0;
+  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) {
-        EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.acknowledgeIncomingGsmSmsWithPdu() for the response returned.
  */
 TEST_F(RadioHidlTest, acknowledgeIncomingGsmSmsWithPdu) {
-    int serial = 0;
-    bool success = true;
-    std::string ackPdu = "";
+  int serial = 0;
+  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 = 0;
 
-    // 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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+  }
 }
 
 /*
  * Test IRadio.acknowledgeLastIncomingCdmaSms() for the response returned.
  */
 TEST_F(RadioHidlTest, acknowledgeLastIncomingCdmaSms) {
-    int serial = 0;
+  int serial = 0;
 
-    // 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) {
-        EXPECT_EQ(RadioError::NO_SMS_TO_ACK, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::NO_SMS_TO_ACK, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.sendImsSms() for the response returned.
  */
 TEST_F(RadioHidlTest, sendImsSms) {
-    int serial = 1;
+  int serial = 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};
 
-    // 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) {
-        EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.getSmscAddress() for the response returned.
  */
 TEST_F(RadioHidlTest, getSmscAddress) {
-    int serial = 0;
+  int serial = 0;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                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 = 0;
+  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) {
-        EXPECT_EQ(RadioError::INVALID_SMS_FORMAT, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::INVALID_SMS_FORMAT, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * 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 = 0;
+  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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.deleteSmsOnSim() for the response returned.
  */
 TEST_F(RadioHidlTest, deleteSmsOnSim) {
-    int serial = 0;
-    int index = 1;
+  int serial = 0;
+  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) {
-        EXPECT_EQ(RadioError::INVALID_SMS_FORMAT, radioRsp->rspInfo.error);
-        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::INVALID_SMS_FORMAT, radioRsp->rspInfo.error);
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
+  }
 }
 
 /*
  * Test IRadio.writeSmsToRuim() for the response returned.
  */
 TEST_F(RadioHidlTest, writeSmsToRuim) {
-    int serial = 0;
+  int serial = 0;
 
-    // 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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.deleteSmsOnRuim() for the response returned.
  */
 TEST_F(RadioHidlTest, deleteSmsOnRuim) {
-    int serial = 0;
-    int index = 1;
+  int serial = 0;
+  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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
+  }
 }
 
 /*
  * Test IRadio.reportSmsMemoryStatus() for the response returned.
  */
 TEST_F(RadioHidlTest, reportSmsMemoryStatus) {
-    int serial = 0;
-    bool available = true;
+  int serial = 0;
+  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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+  }
 }
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 f6d576d..b02a740 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_stk.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_stk.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
 
 using namespace ::android::hardware::radio::V1_0;
 
@@ -22,132 +22,133 @@
  * Test IRadio.sendEnvelope() for the response returned.
  */
 TEST_F(RadioHidlTest, sendEnvelope) {
-    int serial = 0;
+  int serial = 0;
 
-    // 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) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 
-    // Test with sending random string
-    content = "0";
+  // Test with sending random string
+  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) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.sendTerminalResponseToSim() for the response returned.
  */
 TEST_F(RadioHidlTest, sendTerminalResponseToSim) {
-    int serial = 0;
+  int serial = 0;
 
-    // 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";
+  // Test with sending random string
+  commandResponse = "0";
 
-    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 IRadio.handleStkCallSetupRequestFromSim() for the response returned.
  */
 TEST_F(RadioHidlTest, handleStkCallSetupRequestFromSim) {
-    int serial = 0;
-    bool accept = false;
+  int serial = 0;
+  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) {
-        EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 }
 
 /*
  * Test IRadio.reportStkServiceIsRunning() for the response returned.
  */
 TEST_F(RadioHidlTest, reportStkServiceIsRunning) {
-    int serial = 0;
+  int serial = 0;
 
-    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) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 }
 
 /*
- * Test IRadio.sendEnvelopeWithStatus() for the response returned with empty string.
+ * Test IRadio.sendEnvelopeWithStatus() for the response returned with empty
+ * string.
  */
 TEST_F(RadioHidlTest, sendEnvelopeWithStatus) {
-    int serial = 0;
+  int serial = 0;
 
-    // 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) {
+    EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+  }
 
-    // Test with sending random string
-    contents = "0";
+  // Test with sending random string
+  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_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
+  }
 }
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 db7356f..9094f39 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
@@ -14,48 +14,47 @@
  * limitations under the License.
  */
 
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
 
 void RadioHidlTest::SetUp() {
-    radio = ::testing::VtsHalHidlTargetTestBase::getService<IRadio>(hidl_string("rild"));
-    ASSERT_NE(radio, nullptr);
+  radio = ::testing::VtsHalHidlTargetTestBase::getService<IRadio>(
+      hidl_string("rild"));
+  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);
+  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);
 }
 
-void RadioHidlTest::TearDown() {
-}
+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;
 }
-
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 126ad0d..6826238 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_utils.h
+++ b/radio/1.0/vts/functional/radio_hidl_hal_utils.h
@@ -22,8 +22,8 @@
 #include <mutex>
 
 #include <android/hardware/radio/1.0/IRadio.h>
-#include <android/hardware/radio/1.0/IRadioResponse.h>
 #include <android/hardware/radio/1.0/IRadioIndication.h>
+#include <android/hardware/radio/1.0/IRadioResponse.h>
 #include <android/hardware/radio/1.0/types.h>
 
 using ::android::hardware::radio::V1_0::ActivityStatsInfo;
@@ -87,387 +87,426 @@
 
 /* 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();
 
-    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() {}
 };
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 fa2871d..ef10d10 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_voice.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_voice.cpp
@@ -14,471 +14,471 @@
  * limitations under the License.
  */
 
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
 
 /*
  * Test IRadio.getCurrentCalls() for the response returned.
  */
 TEST_F(RadioHidlTest, getCurrentCalls) {
-    int serial = 1;
+  int serial = 1;
 
-    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 = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.hangup() for the response returned.
  */
 TEST_F(RadioHidlTest, hangup) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.hangupWaitingOrBackground() for the response returned.
  */
 TEST_F(RadioHidlTest, hangupWaitingOrBackground) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.hangupForegroundResumeBackground() for the response returned.
  */
 TEST_F(RadioHidlTest, hangupForegroundResumeBackground) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.switchWaitingOrHoldingAndActive() for the response returned.
  */
 TEST_F(RadioHidlTest, switchWaitingOrHoldingAndActive) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.conference() for the response returned.
  */
 TEST_F(RadioHidlTest, conference) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.rejectCall() for the response returned.
  */
 TEST_F(RadioHidlTest, rejectCall) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.getLastCallFailCause() for the response returned.
  */
 TEST_F(RadioHidlTest, getLastCallFailCause) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::NONE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(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 = 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);
 
-    if (cardStatus.cardState == CardState::ABSENT) {
-        ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.cancelPendingUssd() for the response returned.
  */
 TEST_F(RadioHidlTest, cancelPendingUssd) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_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 = 1;
+  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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_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 = 1;
+  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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.getCallWaiting() for the response returned.
  */
 TEST_F(RadioHidlTest, getCallWaiting) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::NONE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::NONE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.setCallWaiting() for the response returned.
  */
 TEST_F(RadioHidlTest, setCallWaiting) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.acceptCall() for the response returned.
  */
 TEST_F(RadioHidlTest, acceptCall) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.separateConnection() for the response returned.
  */
 TEST_F(RadioHidlTest, separateConnection) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.explicitCallTransfer() for the response returned.
  */
 TEST_F(RadioHidlTest, explicitCallTransfer) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.sendCDMAFeatureCode() for the response returned.
  */
 TEST_F(RadioHidlTest, sendCDMAFeatureCode) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
+  }
 }
 
 /*
  * Test IRadio.sendDtmf() for the response returned.
  */
 TEST_F(RadioHidlTest, sendDtmf) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::NO_RESOURCES
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::NO_RESOURCES ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+  }
 }
 
 /*
  * Test IRadio.startDtmf() for the response returned.
  */
 TEST_F(RadioHidlTest, startDtmf) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.stopDtmf() for the response returned.
  */
 TEST_F(RadioHidlTest, stopDtmf) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+  }
 }
 
 /*
  * Test IRadio.setMute() for the response returned.
  */
 TEST_F(RadioHidlTest, setMute) {
-    int serial = 1;
+  int serial = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::NONE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(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 = 1;
 
-    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 = 1;
 
-    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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
-                || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
-                || radioRsp->rspInfo.error == RadioError::MODEM_ERR
-                || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR
-                || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
-    }
+  if (cardStatus.cardState == CardState::ABSENT) {
+    ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+                radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+                radioRsp->rspInfo.error == RadioError::INTERNAL_ERR ||
+                radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+  }
 }
\ 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 c889a18..22c20a5 100644
--- a/radio/1.0/vts/functional/radio_response.cpp
+++ b/radio/1.0/vts/functional/radio_response.cpp
@@ -14,913 +14,959 @@
  * limitations under the License.
  */
 
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
 
 CardStatus cardStatus;
 
-RadioResponse::RadioResponse(RadioHidlTest& parent) : parent(parent) {
-}
+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();
+    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();
+    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();
+    const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::supplyIccPin2ForAppResponse(
-        const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
+    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();
+    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();
+    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();
+    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();
+    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();
+    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();
+    const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::hangupWaitingOrBackgroundResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::hangupForegroundResumeBackgroundResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::switchWaitingOrHoldingAndActiveResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
-Return<void> RadioResponse::conferenceResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+Return<void> RadioResponse::conferenceResponse(const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
-Return<void> RadioResponse::rejectCallResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+Return<void> RadioResponse::rejectCallResponse(const RadioResponseInfo& info) {
+  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();
+    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 ::android::hardware::hidl_string& /*shortName*/,
-        const ::android::hardware::hidl_string& /*numeric*/) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    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();
 }
 
-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();
+                                            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();
+    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();
+    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();
+Return<void> RadioResponse::iccIOForAppResponse(const RadioResponseInfo& info,
+                                                const IccIoResult& iccIo) {
+  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>&
-        /*callForwardInfos*/) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    const RadioResponseInfo& info,
+    const ::android::hardware::hidl_vec<CallForwardInfo>&
+    /*callForwardInfos*/) {
+  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();
+    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();
+    const RadioResponseInfo& info, bool /*manual*/) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::setNetworkSelectionModeAutomaticResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::setNetworkSelectionModeManualResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    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();
+    const RadioResponseInfo& info,
+    const ::android::hardware::hidl_vec<OperatorInfo>& /*networkInfos*/) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
-Return<void> RadioResponse::startDtmfResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+Return<void> RadioResponse::startDtmfResponse(const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
-Return<void> RadioResponse::stopDtmfResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+Return<void> RadioResponse::stopDtmfResponse(const RadioResponseInfo& info) {
+  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();
+                                            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();
+    const RadioResponseInfo& info,
+    const ::android::hardware::hidl_vec<SetupDataCallResult>& /*dcResponse*/) {
+  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 RadioResponseInfo& /*info*/,
+    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();
+    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();
+    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();
+    const RadioResponseInfo& info,
+    const ::android::hardware::hidl_vec<RadioBandMode>& /*bandModes*/) {
+  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();
+Return<void> RadioResponse::sendEnvelopeResponse(
+    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();
+    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::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();
+    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();
+    const RadioResponseInfo& info,
+    const ::android::hardware::hidl_vec<NeighboringCell>& /*cells*/) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::setLocationUpdatesResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    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();
+    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();
+                                               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();
+    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();
+Return<void> RadioResponse::sendCdmaSmsResponse(const RadioResponseInfo& info,
+                                                const SendSmsResult& sms) {
+  rspInfo = info;
+  sendSmsResult = sms;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::acknowledgeLastIncomingCdmaSmsResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    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 RadioResponseInfo& info,
+    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 RadioResponseInfo& info,
+    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 ::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();
+    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();
 }
 
 Return<void> RadioResponse::writeSmsToRuimResponse(
-        const RadioResponseInfo& info, uint32_t index) {
-    rspInfo = info;
-    writeSmsToRuimIndex = index;
-    parent.notify();
-    return Void();
+    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();
+    const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::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*/) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    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();
 }
 
-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();
+    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();
+    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();
+    const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::sendEnvelopeWithStatusResponse(
-        const RadioResponseInfo& info, const IccIoResult& /*iccIo*/) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    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();
+    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();
+    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();
+Return<void> RadioResponse::sendImsSmsResponse(const RadioResponseInfo& info,
+                                               const SendSmsResult& sms) {
+  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();
+    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();
+    const RadioResponseInfo& info, int32_t channelId,
+    const ::android::hardware::hidl_vec<int8_t>& /*selectResponse*/) {
+  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();
+    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();
+    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();
+    const RadioResponseInfo& info,
+    const ::android::hardware::hidl_vec<HardwareConfig>& /*config*/) {
+  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();
+    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();
+    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();
+    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();
+    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();
+    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();
+    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();
+    const RadioResponseInfo& info, const ActivityStatsInfo& /*activityInfo*/) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::setAllowedCarriersResponse(
-        const RadioResponseInfo& info, int32_t /*numAllowed*/) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    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();
+    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();
+    const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::setIndicationFilterResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    const RadioResponseInfo& info) {
+  rspInfo = info;
+  parent.notify();
+  return Void();
 }
 
 Return<void> RadioResponse::setSimCardPowerResponse(
-        const RadioResponseInfo& info) {
-    rspInfo = info;
-    parent.notify();
-    return Void();
+    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 563d066..3a06ecd 100644
--- a/radio/1.0/vts/functional/sap_callback.cpp
+++ b/radio/1.0/vts/functional/sap_callback.cpp
@@ -14,79 +14,82 @@
  * limitations under the License.
  */
 
-#include<sap_hidl_hal_utils.h>
+#include <sap_hidl_hal_utils.h>
 
-SapCallback::SapCallback(SapHidlTest& parent) : parent(parent) {
-}
+SapCallback::SapCallback(SapHidlTest& parent) : parent(parent) {}
 
-Return<void> SapCallback::connectResponse(int32_t token, SapConnectRsp /*sapConnectRsp*/,
-        int32_t /*maxMsgSize*/) {
-    sapResponseToken = token;
-    parent.notify();
-    return Void();
+Return<void> SapCallback::connectResponse(int32_t token,
+                                          SapConnectRsp /*sapConnectRsp*/,
+                                          int32_t /*maxMsgSize*/) {
+  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();
+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();
 }
 
-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();
+                                                   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 e806bd7..682230c 100644
--- a/radio/1.0/vts/functional/sap_hidl_hal_api.cpp
+++ b/radio/1.0/vts/functional/sap_hidl_hal_api.cpp
@@ -14,44 +14,44 @@
  * limitations under the License.
  */
 
-#include<sap_hidl_hal_utils.h>
+#include <sap_hidl_hal_utils.h>
 
 /*
  * Test ISap.connectReq() for the response returned.
  */
 TEST_F(SapHidlTest, connectReq) {
-    int32_t token = 0;
-    int32_t maxMsgSize = 100;
+  int32_t token = 0;
+  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 = 0;
 
-    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 = 0;
+  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::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
+  ASSERT_TRUE(SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
               SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
               SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
 }
@@ -60,13 +60,13 @@
  * Test IRadio.transferAtrReq() for the response returned.
  */
 TEST_F(SapHidlTest, transferAtrReq) {
-    int32_t token = 0;
+  int32_t token = 0;
 
-    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::DATA_NOT_AVAILABLE == sapCb->sapResultCode ||
+  ASSERT_TRUE(SapResultCode::DATA_NOT_AVAILABLE == sapCb->sapResultCode ||
               SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
               SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
 }
@@ -75,14 +75,14 @@
  * Test IRadio.powerReq() for the response returned.
  */
 TEST_F(SapHidlTest, powerReq) {
-    int32_t token = 0;
-    bool state = true;
+  int32_t token = 0;
+  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::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
+  ASSERT_TRUE(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);
@@ -92,13 +92,13 @@
  * Test IRadio.resetSimReq() for the response returned.
  */
 TEST_F(SapHidlTest, resetSimReq) {
-    int32_t token = 0;
+  int32_t token = 0;
 
-    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::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
+  ASSERT_TRUE(SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
               SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
               SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
 }
@@ -107,25 +107,25 @@
  * Test IRadio.transferCardReaderStatusReq() for the response returned.
  */
 TEST_F(SapHidlTest, transferCardReaderStatusReq) {
-    int32_t token = 0;
+  int32_t token = 0;
 
-    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);
 
-    EXPECT_EQ(SapResultCode::DATA_NOT_AVAILABLE, sapCb->sapResultCode);
+  EXPECT_EQ(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 = 0;
+  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 a67c5b6..88274cd 100644
--- a/radio/1.0/vts/functional/sap_hidl_hal_test.cpp
+++ b/radio/1.0/vts/functional/sap_hidl_hal_test.cpp
@@ -14,41 +14,40 @@
  * limitations under the License.
  */
 
-#include<sap_hidl_hal_utils.h>
+#include <sap_hidl_hal_utils.h>
 
 void SapHidlTest::SetUp() {
-    sap = ::testing::VtsHalHidlTargetTestBase::getService<ISap>(hidl_string("sap_uim_socket1"));
-    ASSERT_NE(sap, nullptr);
+  sap = ::testing::VtsHalHidlTargetTestBase::getService<ISap>(
+      hidl_string("sap_uim_socket1"));
+  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::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;
 }
-
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 e3efa50..2ee3c96 100644
--- a/radio/1.0/vts/functional/sap_hidl_hal_utils.h
+++ b/radio/1.0/vts/functional/sap_hidl_hal_utils.h
@@ -39,71 +39,77 @@
 
 /* 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() {}
 };