diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..787d47a
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,28 @@
+#
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#
+# Below are some minor deviations from the default Google style to
+# accommodate for handling of the large legacy code base.
+#
+
+BasedOnStyle: Google
+CommentPragmas: NOLINT:.*
+DerivePointerAlignment: false
+AllowShortFunctionsOnASingleLine: Inline
+TabWidth: 4
+UseTab: Never
+IndentWidth: 4
diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg
new file mode 100644
index 0000000..213c93a
--- /dev/null
+++ b/PREUPLOAD.cfg
@@ -0,0 +1,5 @@
+[Options]
+ignore_merged_commits = true
+
+[Builtin Hooks]
+clang_format = true
diff --git a/automotive/Android.bp b/automotive/Android.bp
index 9b24ded..aec8865 100644
--- a/automotive/Android.bp
+++ b/automotive/Android.bp
@@ -2,6 +2,7 @@
 subdirs = [
     "evs/1.0",
     "evs/1.0/default",
+    "evs/1.0/vts/functional",
     "vehicle/2.0",
     "vehicle/2.1",
 ]
diff --git a/automotive/evs/1.0/vts/functional/Android.bp b/automotive/evs/1.0/vts/functional/Android.bp
new file mode 100644
index 0000000..22ceff3
--- /dev/null
+++ b/automotive/evs/1.0/vts/functional/Android.bp
@@ -0,0 +1,45 @@
+//
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+cc_test {
+    name: "VtsEvsV1_0Target",
+
+    srcs: [
+        "VtsEvsV1_0TargetTest.cpp",
+        "FrameHandler.cpp"
+    ],
+
+    defaults: [
+        "hidl_defaults",
+    ],
+
+    shared_libs: [
+        "android.hardware.automotive.evs@1.0",
+        "liblog",
+        "libutils",
+        "libui",
+        "libhidlbase",
+        "libhidltransport",
+    ],
+
+    static_libs: ["VtsHalHidlTargetTestBase"],
+
+    cflags: [
+        "-O0",
+        "-g",
+    ],
+}
+
diff --git a/automotive/evs/1.0/vts/functional/FrameHandler.cpp b/automotive/evs/1.0/vts/functional/FrameHandler.cpp
new file mode 100644
index 0000000..01d9a0e
--- /dev/null
+++ b/automotive/evs/1.0/vts/functional/FrameHandler.cpp
@@ -0,0 +1,311 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "VtsHalEvsTest"
+
+#include "FrameHandler.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <android/log.h>
+#include <cutils/native_handle.h>
+#include <ui/GraphicBufferMapper.h>
+#include <ui/GraphicBuffer.h>
+
+#include <algorithm>    // std::min
+
+
+// For the moment, we're assuming that the underlying EVS driver we're working with
+// is providing 4 byte RGBx data.  This is fine for loopback testing, although
+// real hardware is expected to provide YUV data -- most likly formatted as YV12
+static const unsigned kBytesPerPixel = 4;   // assuming 4 byte RGBx pixels
+
+
+FrameHandler::FrameHandler(android::sp <IEvsCamera> pCamera, CameraDesc cameraInfo,
+                           android::sp <IEvsDisplay> pDisplay,
+                           BufferControlFlag mode) :
+    mCamera(pCamera),
+    mCameraInfo(cameraInfo),
+    mDisplay(pDisplay),
+    mReturnMode(mode) {
+    // Nothing but member initialization here...
+}
+
+
+void FrameHandler::shutdown()
+{
+    // Make sure we're not still streaming
+    blockingStopStream();
+
+    // At this point, the receiver thread is no longer running, so we can safely drop
+    // our remote object references so they can be freed
+    mCamera = nullptr;
+    mDisplay = nullptr;
+}
+
+
+bool FrameHandler::startStream() {
+    // Mark ourselves as running
+    mLock.lock();
+    mRunning = true;
+    mLock.unlock();
+
+    // Tell the camera to start streaming
+    Return<EvsResult> result = mCamera->startVideoStream(this);
+    return (result == EvsResult::OK);
+}
+
+
+void FrameHandler::asyncStopStream() {
+    // Tell the camera to stop streaming.
+    // This will result in a null frame being delivered when the stream actually stops.
+    mCamera->stopVideoStream();
+}
+
+
+void FrameHandler::blockingStopStream() {
+    // Tell the stream to stop
+    asyncStopStream();
+
+    // Wait until the stream has actually stopped
+    std::unique_lock<std::mutex> lock(mLock);
+    mSignal.wait(lock, [this](){ return !mRunning; });
+}
+
+
+bool FrameHandler::returnHeldBuffer() {
+    std::unique_lock<std::mutex> lock(mLock);
+
+    // Return the oldest buffer we're holding
+    if (mHeldBuffers.empty()) {
+        // No buffers are currently held
+        return false;
+    }
+
+    BufferDesc buffer = mHeldBuffers.front();
+    mHeldBuffers.pop();
+    mCamera->doneWithFrame(buffer);
+
+    return true;
+}
+
+
+bool FrameHandler::isRunning() {
+    std::unique_lock<std::mutex> lock(mLock);
+    return mRunning;
+}
+
+
+void FrameHandler::waitForFrameCount(unsigned frameCount) {
+    // Wait until we've seen at least the requested number of frames (could be more)
+    std::unique_lock<std::mutex> lock(mLock);
+    mSignal.wait(lock, [this, frameCount](){ return mFramesReceived >= frameCount; });
+}
+
+
+void FrameHandler::getFramesCounters(unsigned* received, unsigned* displayed) {
+    std::unique_lock<std::mutex> lock(mLock);
+
+    if (received) {
+        *received = mFramesReceived;
+    }
+    if (displayed) {
+        *displayed = mFramesDisplayed;
+    }
+}
+
+
+Return<void> FrameHandler::deliverFrame(const BufferDesc& bufferArg) {
+    ALOGD("Received a frame from the camera (%p)", bufferArg.memHandle.getNativeHandle());
+
+    // Local flag we use to keep track of when the stream is stopping
+    bool timeToStop = false;
+
+    // TODO:  Why do we get a gralloc crash if we don't clone the buffer here?
+    BufferDesc buffer(bufferArg);
+    ALOGD("Clone the received frame as %p", buffer.memHandle.getNativeHandle());
+
+    if (buffer.memHandle.getNativeHandle() == nullptr) {
+        // Signal that the last frame has been received and the stream is stopped
+        timeToStop = true;
+    } else {
+        // If we were given an opened display at construction time, then send the received
+        // image back down the camera.
+        if (mDisplay.get()) {
+            // Get the output buffer we'll use to display the imagery
+            BufferDesc tgtBuffer = {};
+            mDisplay->getTargetBuffer([&tgtBuffer](const BufferDesc& buff) {
+                                          tgtBuffer = buff;
+                                      }
+            );
+
+            if (tgtBuffer.memHandle == nullptr) {
+                printf("Didn't get target buffer - frame lost\n");
+                ALOGE("Didn't get requested output buffer -- skipping this frame.");
+            } else {
+                // In order for the handles passed through HIDL and stored in the BufferDesc to
+                // be lockable, we must register them with GraphicBufferMapper
+                registerBufferHelper(tgtBuffer);
+                registerBufferHelper(buffer);
+
+                // Copy the contents of the of buffer.memHandle into tgtBuffer
+                copyBufferContents(tgtBuffer, buffer);
+
+                // Send the target buffer back for display
+                Return <EvsResult> result = mDisplay->returnTargetBufferForDisplay(tgtBuffer);
+                if (!result.isOk()) {
+                    printf("HIDL error on display buffer (%s)- frame lost\n",
+                           result.description().c_str());
+                    ALOGE("Error making the remote function call.  HIDL said %s",
+                          result.description().c_str());
+                } else if (result != EvsResult::OK) {
+                    printf("Display reported error - frame lost\n");
+                    ALOGE("We encountered error %d when returning a buffer to the display!",
+                          (EvsResult) result);
+                } else {
+                    // Everything looks good!
+                    // Keep track so tests or watch dogs can monitor progress
+                    mLock.lock();
+                    mFramesDisplayed++;
+                    mLock.unlock();
+                }
+
+                // Now tell GraphicBufferMapper we won't be using these handles anymore
+                unregisterBufferHelper(tgtBuffer);
+                unregisterBufferHelper(buffer);
+            }
+        }
+
+
+        switch (mReturnMode) {
+        case eAutoReturn:
+            // Send the camera buffer back now that we're done with it
+            ALOGD("Calling doneWithFrame");
+            // TODO:  Why is it that we get a HIDL crash if we pass back the cloned buffer?
+            mCamera->doneWithFrame(bufferArg);
+            break;
+        case eNoAutoReturn:
+            // Hang onto the buffer handle for now -- we'll return it explicitly later
+            mHeldBuffers.push(bufferArg);
+        }
+
+
+        ALOGD("Frame handling complete");
+    }
+
+
+    // Update our received frame count and notify anybody who cares that things have changed
+    mLock.lock();
+    if (timeToStop) {
+        mRunning = false;
+    } else {
+        mFramesReceived++;
+    }
+    mLock.unlock();
+    mSignal.notify_all();
+
+
+    return Void();
+}
+
+
+bool FrameHandler::copyBufferContents(const BufferDesc& tgtBuffer,
+                                      const BufferDesc& srcBuffer) {
+    bool success = true;
+
+    // Make sure we don't run off the end of either buffer
+    const unsigned width     = std::min(tgtBuffer.width,
+                                        srcBuffer.width);
+    const unsigned height    = std::min(tgtBuffer.height,
+                                        srcBuffer.height);
+
+    android::GraphicBufferMapper &mapper = android::GraphicBufferMapper::get();
+
+
+    // Lock our source buffer for reading
+    unsigned char* srcPixels = nullptr;
+    mapper.registerBuffer(srcBuffer.memHandle);
+    mapper.lock(srcBuffer.memHandle,
+                GRALLOC_USAGE_SW_READ_OFTEN,
+                android::Rect(width, height),
+                (void **) &srcPixels);
+
+    // Lock our target buffer for writing
+    unsigned char* tgtPixels = nullptr;
+    mapper.registerBuffer(tgtBuffer.memHandle);
+    mapper.lock(tgtBuffer.memHandle,
+                GRALLOC_USAGE_SW_WRITE_OFTEN,
+                android::Rect(width, height),
+                (void **) &tgtPixels);
+
+    if (srcPixels && tgtPixels) {
+        for (unsigned row = 0; row < height; row++) {
+            // Copy the entire row of pixel data
+            memcpy(tgtPixels, srcPixels, width * kBytesPerPixel);
+
+            // Advance to the next row (keeping in mind that stride here is in units of pixels)
+            tgtPixels += tgtBuffer.stride * kBytesPerPixel;
+            srcPixels += srcBuffer.stride * kBytesPerPixel;
+        }
+    } else {
+        ALOGE("Failed to copy buffer contents");
+        success = false;
+    }
+
+    if (srcPixels) {
+        mapper.unlock(srcBuffer.memHandle);
+    }
+    if (tgtPixels) {
+        mapper.unlock(tgtBuffer.memHandle);
+    }
+    mapper.unregisterBuffer(srcBuffer.memHandle);
+    mapper.unregisterBuffer(tgtBuffer.memHandle);
+
+    return success;
+}
+
+
+void FrameHandler::registerBufferHelper(const BufferDesc& buffer)
+{
+    // In order for the handles passed through HIDL and stored in the BufferDesc to
+    // be lockable, we must register them with GraphicBufferMapper.
+    // If the device upon which we're running supports gralloc1, we could just call
+    // registerBuffer directly with the handle.  But that call  is broken for gralloc0 devices
+    // (which we care about, at least for now).  As a result, we have to synthesize a GraphicBuffer
+    // object around the buffer handle in order to make a call to the overloaded alternate
+    // version of the registerBuffer call that does happen to work on gralloc0 devices.
+#if REGISTER_BUFFER_ALWAYS_WORKS
+    android::GraphicBufferMapper::get().registerBuffer(buffer.memHandle);
+#else
+    android::sp<android::GraphicBuffer> pGfxBuff = new android::GraphicBuffer(
+            buffer.width, buffer.height, buffer.format,
+            1, /* we always use exactly one layer */
+            buffer.usage, buffer.stride,
+            const_cast<native_handle_t*>(buffer.memHandle.getNativeHandle()),
+            false /* GraphicBuffer should not try to free the handle */
+    );
+
+    android::GraphicBufferMapper::get().registerBuffer(pGfxBuff.get());
+#endif
+}
+
+
+void FrameHandler::unregisterBufferHelper(const BufferDesc& buffer)
+{
+    // Now tell GraphicBufferMapper we won't be using these handles anymore
+    android::GraphicBufferMapper::get().unregisterBuffer(buffer.memHandle);
+}
diff --git a/automotive/evs/1.0/vts/functional/FrameHandler.h b/automotive/evs/1.0/vts/functional/FrameHandler.h
new file mode 100644
index 0000000..d5c3f6b
--- /dev/null
+++ b/automotive/evs/1.0/vts/functional/FrameHandler.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef EVS_VTS_FRAMEHANDLER_H
+#define EVS_VTS_FRAMEHANDLER_H
+
+#include <queue>
+
+#include <android/hardware/automotive/evs/1.0/IEvsCameraStream.h>
+#include <android/hardware/automotive/evs/1.0/IEvsCamera.h>
+#include <android/hardware/automotive/evs/1.0/IEvsDisplay.h>
+
+using namespace ::android::hardware::automotive::evs::V1_0;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_handle;
+using ::android::sp;
+
+
+/*
+ * FrameHandler:
+ * This class can be used to receive camera imagery from an IEvsCamera implementation.  Given an
+ * IEvsDisplay instance at startup, it will forward the received imagery to the display,
+ * providing a trivial implementation of a rear vew camera type application.
+ * Note that the video frames are delivered on a background thread, while the control interface
+ * is actuated from the applications foreground thread.
+ */
+class FrameHandler : public IEvsCameraStream {
+public:
+    enum BufferControlFlag {
+        eAutoReturn,
+        eNoAutoReturn,
+    };
+
+    FrameHandler(android::sp <IEvsCamera> pCamera, CameraDesc cameraInfo,
+                 android::sp <IEvsDisplay> pDisplay = nullptr,
+                 BufferControlFlag mode = eAutoReturn);
+    void shutdown();
+
+    bool startStream();
+    void asyncStopStream();
+    void blockingStopStream();
+
+    bool returnHeldBuffer();
+
+    bool isRunning();
+
+    void waitForFrameCount(unsigned frameCount);
+    void getFramesCounters(unsigned* received, unsigned* displayed);
+
+private:
+    // Implementation for ::android::hardware::automotive::evs::V1_0::ICarCameraStream
+    Return<void> deliverFrame(const BufferDesc& buffer)  override;
+
+    // Local implementation details
+    bool copyBufferContents(const BufferDesc& tgtBuffer, const BufferDesc& srcBuffer);
+    void registerBufferHelper(const BufferDesc& buffer);
+    void unregisterBufferHelper(const BufferDesc& buffer);
+
+    // Values initialized as startup
+    android::sp <IEvsCamera>    mCamera;
+    CameraDesc                  mCameraInfo;
+    android::sp <IEvsDisplay>   mDisplay;
+    BufferControlFlag           mReturnMode;
+
+    // Since we get frames delivered to us asnchronously via the ICarCameraStream interface,
+    // we need to protect all member variables that may be modified while we're streaming
+    // (ie: those below)
+    std::mutex                  mLock;
+    std::condition_variable     mSignal;
+
+    std::queue<BufferDesc>      mHeldBuffers;
+    bool                        mRunning = false;
+    unsigned                    mFramesReceived = 0;    // Simple counter -- rolls over eventually!
+    unsigned                    mFramesDisplayed = 0;   // Simple counter -- rolls over eventually!
+};
+
+
+#endif //EVS_VTS_FRAMEHANDLER_H
diff --git a/automotive/evs/1.0/vts/functional/VtsEvsV1_0TargetTest.cpp b/automotive/evs/1.0/vts/functional/VtsEvsV1_0TargetTest.cpp
new file mode 100644
index 0000000..6a0ae48
--- /dev/null
+++ b/automotive/evs/1.0/vts/functional/VtsEvsV1_0TargetTest.cpp
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "VtsHalEvsTest"
+
+
+// TODO:  How should we configure these values to target appropriate hardware?
+const static char kEnumeratorName[]  = "EvsEnumeratorHw-Mock";
+
+
+// These values are called out in the EVS design doc (as of Mar 8, 2017)
+static const int kMaxStreamStartMilliseconds = 500;
+static const int kMinimumFramesPerSecond = 10;
+
+static const int kSecondsToMilliseconds = 1000;
+static const int kMillisecondsToMicroseconds = 1000;
+static const float kNanoToMilliseconds = 0.000001f;
+static const float kNanoToSeconds = 0.000000001f;
+
+
+#include "FrameHandler.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <hidl/HidlTransportSupport.h>
+#include <utils/Errors.h>
+#include <utils/StrongPointer.h>
+#include <utils/Log.h>
+#include <hwbinder/ProcessState.h>
+
+#include <android/log.h>
+#include <android/hardware/automotive/evs/1.0/IEvsCamera.h>
+#include <android/hardware/automotive/evs/1.0/IEvsEnumerator.h>
+#include <android/hardware/automotive/evs/1.0/IEvsCameraStream.h>
+#include <android/hardware/automotive/evs/1.0/IEvsDisplay.h>
+
+#include <VtsHalHidlTargetTestBase.h>
+
+
+using namespace ::android::hardware::automotive::evs::V1_0;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_handle;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+
+// The main test class for EVS
+class EvsHidlTest : public ::testing::VtsHalHidlTargetTestBase {
+public:
+    virtual void SetUp() override {
+        // Make sure we can connect to the enumerator
+        pEnumerator = IEvsEnumerator::getService(kEnumeratorName);
+        ASSERT_NE(pEnumerator.get(), nullptr);
+    }
+
+    virtual void TearDown() override {}
+
+protected:
+    void loadCameraList() {
+        // SetUp() must run first!
+        assert(pEnumerator != nullptr);
+
+        // Get the camera list
+        pEnumerator->getCameraList([this](hidl_vec <CameraDesc> cameraList) {
+                                       ALOGI("Camera list callback received %zu cameras",
+                                             cameraList.size());
+                                       cameraInfo.reserve(cameraList.size());
+                                       for (auto&& cam: cameraList) {
+                                           ALOGI("Found camera %s", cam.cameraId.c_str());
+                                           cameraInfo.push_back(cam);
+                                       }
+                                   }
+        );
+
+        // We insist on at least one camera for EVS to pass any camera tests
+        ASSERT_GE(cameraInfo.size(), 1u);
+    }
+
+    sp<IEvsEnumerator>          pEnumerator;    // Every test needs access to the service
+    std::vector <CameraDesc>    cameraInfo;     // Empty unless/until loadCameraList() is called
+};
+
+
+//
+// Tests start here...
+//
+
+/*
+ * CameraOpenClean:
+ * Opens each camera reported by the enumerator and then explicitly closes it via a
+ * call to closeCamera.  Then repeats the test to ensure all cameras can be reopened.
+ */
+TEST_F(EvsHidlTest, CameraOpenClean) {
+    // Get the camera list
+    loadCameraList();
+
+    // Open and close each camera twice
+    for (auto&& cam: cameraInfo) {
+        for (int pass = 0; pass < 2; pass++) {
+            sp<IEvsCamera> pCam = pEnumerator->openCamera(cam.cameraId);
+            ASSERT_NE(pCam, nullptr);
+
+            // Verify that this camera self-identifies correctly
+            pCam->getCameraInfo([&cam](CameraDesc desc) {
+                                    ALOGD("Found camera %s", desc.cameraId.c_str());
+                                    EXPECT_EQ(cam.cameraId, desc.cameraId);
+                                }
+            );
+
+            // Explicitly close the camera so resources are released right away
+            pEnumerator->closeCamera(pCam);
+        }
+    }
+}
+
+
+/*
+ * CameraOpenAggressive:
+ * Opens each camera reported by the enumerator twice in a row without an intervening closeCamera
+ * call.  This ensures that the intended "aggressive open" behavior works.  This is necessary for
+ * the system to be tolerant of shutdown/restart race conditions.
+ */
+TEST_F(EvsHidlTest, CameraOpenAggressive) {
+    // Get the camera list
+    loadCameraList();
+
+    // Open and close each camera twice
+    for (auto&& cam: cameraInfo) {
+        sp<IEvsCamera> pCam = pEnumerator->openCamera(cam.cameraId);
+        ASSERT_NE(pCam, nullptr);
+
+        // Verify that this camera self-identifies correctly
+        pCam->getCameraInfo([&cam](CameraDesc desc) {
+                                ALOGD("Found camera %s", desc.cameraId.c_str());
+                                EXPECT_EQ(cam.cameraId, desc.cameraId);
+                            }
+        );
+
+        sp<IEvsCamera> pCam2 = pEnumerator->openCamera(cam.cameraId);
+        ASSERT_NE(pCam, pCam2);
+        ASSERT_NE(pCam2, nullptr);
+
+        // Verify that the old camera rejects calls
+        Return<EvsResult> badResult = pCam->setMaxFramesInFlight(2);
+        EXPECT_EQ(EvsResult::OWNERSHIP_LOST, EvsResult(badResult));
+
+        // Close the superceded camera
+        pEnumerator->closeCamera(pCam);
+
+        // Verify that the second camera instance self-identifies correctly
+        pCam2->getCameraInfo([&cam](CameraDesc desc) {
+                                 ALOGD("Found camera %s", desc.cameraId.c_str());
+                                 EXPECT_EQ(cam.cameraId, desc.cameraId);
+                             }
+        );
+
+        // Leave the second camera dangling so it gets cleaned up by the destructor path
+    }
+
+    // Sleep here to ensure the destructor cleanup has time to run so we don't break follow on tests
+    sleep(1);   // I hate that this is an arbitrary time to wait.  :(  b/36122635
+}
+
+
+/*
+ * DisplayOpen:
+ * Test both clean shut down and "aggressive open" device stealing behavior.
+ */
+TEST_F(EvsHidlTest, DisplayOpen) {
+    // Request exclusive access to the EVS display, then let it go
+    {
+        sp<IEvsDisplay> pDisplay = pEnumerator->openDisplay();
+        ASSERT_NE(pDisplay, nullptr);
+
+        // Ask the display what it's name is
+        pDisplay->getDisplayInfo([](DisplayDesc desc) {
+                                     ALOGD("Found display %s", desc.displayId.c_str());
+                                 }
+        );
+
+        pEnumerator->closeDisplay(pDisplay);
+    }
+
+    // Ensure we can reopen the display after it has been closed
+    {
+        // Reopen the display
+        sp<IEvsDisplay> pDisplay = pEnumerator->openDisplay();
+        ASSERT_NE(pDisplay, nullptr);
+
+        // Open the display while its already open -- ownership should be transferred
+        sp<IEvsDisplay> pDisplay2 = pEnumerator->openDisplay();
+        ASSERT_NE(pDisplay2, nullptr);
+
+        // Ensure the old display properly reports its assassination
+        Return<DisplayState> badResult = pDisplay->getDisplayState();
+        EXPECT_EQ(badResult, DisplayState::DEAD);
+
+        // Close only the newest display instance -- the other should already be a zombie
+        pEnumerator->closeDisplay(pDisplay2);
+    }
+
+    // Finally, validate that we can open the display after the provoked failure above
+    sp<IEvsDisplay> pDisplay = pEnumerator->openDisplay();
+    ASSERT_NE(pDisplay, nullptr);
+
+    pEnumerator->closeDisplay(pDisplay);
+}
+
+
+/*
+ * DisplayStates:
+ * Validate that display states transition as expected and can be queried from either the display
+ * object itself or the owning enumerator.
+ */
+TEST_F(EvsHidlTest, DisplayStates) {
+    // Ensure the display starts in the expected state
+    EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::NOT_OPEN);
+
+    // Scope to limit the lifetime of the pDisplay pointer, and thus the IEvsDisplay object
+    {
+        // Request exclusive access to the EVS display
+        sp<IEvsDisplay> pDisplay = pEnumerator->openDisplay();
+        ASSERT_NE(pDisplay, nullptr);
+        EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::NOT_VISIBLE);
+
+        // Activate the display
+        pDisplay->setDisplayState(DisplayState::VISIBLE_ON_NEXT_FRAME);
+        EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::VISIBLE_ON_NEXT_FRAME);
+        EXPECT_EQ((DisplayState)pDisplay->getDisplayState(), DisplayState::VISIBLE_ON_NEXT_FRAME);
+
+        // Get the output buffer we'd use to display the imagery
+        BufferDesc tgtBuffer = {};
+        pDisplay->getTargetBuffer([&tgtBuffer](const BufferDesc& buff) {
+                                      tgtBuffer = buff;
+                                  }
+        );
+        EXPECT_NE(tgtBuffer.memHandle, nullptr);
+
+        // Send the target buffer back for display (we didn't actually fill anything)
+        pDisplay->returnTargetBufferForDisplay(tgtBuffer);
+
+        // Sleep for a tenth of a second to ensure the driver has time to get the image displayed
+        usleep(100 * kMillisecondsToMicroseconds);
+        EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::VISIBLE);
+        EXPECT_EQ((DisplayState)pDisplay->getDisplayState(), DisplayState::VISIBLE);
+
+        // Turn off the display
+        pDisplay->setDisplayState(DisplayState::NOT_VISIBLE);
+        usleep(100 * kMillisecondsToMicroseconds);
+        EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::NOT_VISIBLE);
+
+        // Close the display
+        pEnumerator->closeDisplay(pDisplay);
+    }
+
+    // TODO:  This hack shouldn't be necessary.  b/36122635
+// NOTE:  Calling flushCommand here did not avoid the race.  Going back to sleep...  :(
+//    android::hardware::IPCThreadState::self()->flushCommands();
+    sleep(1);
+
+    // Now that the display pointer has gone out of scope, causing the IEvsDisplay interface
+    // object to be destroyed, we should be back to the "not open" state.
+    // NOTE:  If we want this to pass without the sleep above, we'd have to add the
+    //        (now recommended) closeDisplay() call instead of relying on the smarter pointer
+    //        going out of scope.
+    EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::NOT_OPEN);
+}
+
+
+/*
+ * CameraStreamPerformance:
+ * Measure and qualify the stream start up time and streaming frame rate of each reported camera
+ */
+TEST_F(EvsHidlTest, CameraStreamPerformance) {
+    // Get the camera list
+    loadCameraList();
+
+    // Test each reported camera
+    for (auto&& cam: cameraInfo) {
+        sp <IEvsCamera> pCam = pEnumerator->openCamera(cam.cameraId);
+        ASSERT_NE(pCam, nullptr);
+
+        // Set up a frame receiver object which will fire up its own thread
+        sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
+                                                         nullptr,
+                                                         FrameHandler::eAutoReturn);
+
+        // Start the camera's video stream
+        nsecs_t start = systemTime(SYSTEM_TIME_MONOTONIC);
+        bool startResult = frameHandler->startStream();
+        EXPECT_EQ(startResult, true);
+
+        // Ensure the first frame arrived within the expected time
+        frameHandler->waitForFrameCount(1);
+        nsecs_t firstFrame = systemTime(SYSTEM_TIME_MONOTONIC);
+        nsecs_t timeToFirstFrame = systemTime(SYSTEM_TIME_MONOTONIC) - start;
+        EXPECT_LE(nanoseconds_to_milliseconds(timeToFirstFrame), kMaxStreamStartMilliseconds);
+        printf("Measured time to first frame %0.2f ms\n", timeToFirstFrame * kNanoToMilliseconds);
+        ALOGI("Measured time to first frame %0.2f ms", timeToFirstFrame * kNanoToMilliseconds);
+
+        // Wait a bit, then ensure we get at least the required minimum number of frames
+        sleep(5);
+        nsecs_t end = systemTime(SYSTEM_TIME_MONOTONIC);
+        unsigned framesReceived = 0;
+        frameHandler->getFramesCounters(&framesReceived, nullptr);
+        framesReceived = framesReceived - 1;    // Back out the first frame we already waited for
+        nsecs_t runTime = end - firstFrame;
+        float framesPerSecond = framesReceived / (runTime * kNanoToSeconds);
+        printf("Measured camera rate %3.2f fps\n", framesPerSecond);
+        ALOGI("Measured camera rate %3.2f fps", framesPerSecond);
+        EXPECT_GE(framesPerSecond, kMinimumFramesPerSecond);
+
+        // Even when the camera pointer goes out of scope, the FrameHandler object will
+        // keep the stream alive unless we tell it to shutdown.
+        // Also note that the FrameHandle and the Camera have a mutual circular reference, so
+        // we have to break that cycle in order for either of them to get cleaned up.
+        frameHandler->shutdown();
+
+        // Explicitly release the camera
+        pEnumerator->closeCamera(pCam);
+    }
+}
+
+
+/*
+ * CameraStreamBuffering:
+ * Ensure the camera implementation behaves properly when the client holds onto buffers for more
+ * than one frame time.  The camera must cleanly skip frames until the client is ready again.
+ */
+TEST_F(EvsHidlTest, CameraStreamBuffering) {
+    // Arbitrary constant (should be > 1 and less than crazy)
+    static const unsigned int kBuffersToHold = 6;
+
+    // Get the camera list
+    loadCameraList();
+
+    // Test each reported camera
+    for (auto&& cam: cameraInfo) {
+
+        sp<IEvsCamera> pCam = pEnumerator->openCamera(cam.cameraId);
+        ASSERT_NE(pCam, nullptr);
+
+        // Ask for a crazy number of buffers in flight to ensure it errors correctly
+        Return<EvsResult> badResult = pCam->setMaxFramesInFlight(0xFFFFFFFF);
+        EXPECT_EQ(EvsResult::BUFFER_NOT_AVAILABLE, badResult);
+
+        // Now ask for exactly two buffers in flight as we'll test behavior in that case
+        Return<EvsResult> goodResult = pCam->setMaxFramesInFlight(kBuffersToHold);
+        EXPECT_EQ(EvsResult::OK, goodResult);
+
+
+        // Set up a frame receiver object which will fire up its own thread.
+        sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
+                                                         nullptr,
+                                                         FrameHandler::eNoAutoReturn);
+
+        // Start the camera's video stream
+        bool startResult = frameHandler->startStream();
+        EXPECT_TRUE(startResult);
+
+        // Check that the video stream stalls once we've gotten exactly the number of buffers
+        // we requested since we told the frameHandler not to return them.
+        sleep(1);   // 1 second would be enough for at least 5 frames to be delivered worst case
+        unsigned framesReceived = 0;
+        frameHandler->getFramesCounters(&framesReceived, nullptr);
+        EXPECT_EQ(kBuffersToHold, framesReceived);
+
+
+        // Give back one buffer
+        bool didReturnBuffer = frameHandler->returnHeldBuffer();
+        EXPECT_TRUE(didReturnBuffer);
+
+        // Once we return a buffer, it shouldn't take more than 1/10 second to get a new one
+        // filled since we require 10fps minimum -- but give a 10% allowance just in case.
+        usleep(110 * kMillisecondsToMicroseconds);
+        frameHandler->getFramesCounters(&framesReceived, nullptr);
+        EXPECT_EQ(kBuffersToHold+1, framesReceived);
+
+        // Even when the camera pointer goes out of scope, the FrameHandler object will
+        // keep the stream alive unless we tell it to shutdown.
+        // Also note that the FrameHandle and the Camera have a mutual circular reference, so
+        // we have to break that cycle in order for either of them to get cleaned up.
+        frameHandler->shutdown();
+
+        // Explicitly release the camera
+        pEnumerator->closeCamera(pCam);
+    }
+}
+
+
+/*
+ * CameraToDisplayRoundTrip:
+ * End to end test of data flowing from the camera to the display.  Each delivered frame of camera
+ * imagery is simply copied to the display buffer and presented on screen.  This is the one test
+ * which a human could observe to see the operation of the system on the physical display.
+ */
+TEST_F(EvsHidlTest, CameraToDisplayRoundTrip) {
+    // Get the camera list
+    loadCameraList();
+
+    // Request exclusive access to the EVS display
+    sp<IEvsDisplay> pDisplay = pEnumerator->openDisplay();
+    ASSERT_NE(pDisplay, nullptr);
+
+    // Test each reported camera
+    for (auto&& cam: cameraInfo) {
+        sp <IEvsCamera> pCam = pEnumerator->openCamera(cam.cameraId);
+        ASSERT_NE(pCam, nullptr);
+
+        // Set up a frame receiver object which will fire up its own thread.
+        sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
+                                                         pDisplay,
+                                                         FrameHandler::eAutoReturn);
+
+
+        // Activate the display
+        pDisplay->setDisplayState(DisplayState::VISIBLE_ON_NEXT_FRAME);
+
+        // Start the camera's video stream
+        bool startResult = frameHandler->startStream();
+        EXPECT_EQ(startResult, true);
+
+        // Wait a while to let the data flow
+        static const int kSecondsToWait = 5;
+        const int streamTimeMs = kSecondsToWait * kSecondsToMilliseconds -
+                                 kMaxStreamStartMilliseconds;
+        const unsigned minimumFramesExpected = streamTimeMs * kMinimumFramesPerSecond /
+                                               kSecondsToMilliseconds;
+        sleep(kSecondsToWait);
+        unsigned framesReceived = 0;
+        unsigned framesDisplayed = 0;
+        frameHandler->getFramesCounters(&framesReceived, &framesDisplayed);
+        EXPECT_EQ(framesReceived, framesDisplayed);
+        EXPECT_GE(framesDisplayed, minimumFramesExpected);
+
+        // Turn off the display (yes, before the stream stops -- it should be handled)
+        pDisplay->setDisplayState(DisplayState::NOT_VISIBLE);
+
+        // Shut down the streamer
+        frameHandler->shutdown();
+
+        // Explicitly release the camera
+        pEnumerator->closeCamera(pCam);
+    }
+
+    // Explicitly release the display
+    pEnumerator->closeDisplay(pDisplay);
+}
\ No newline at end of file
diff --git a/automotive/vehicle/2.0/default/Android.mk b/automotive/vehicle/2.0/default/Android.mk
index 4a010e9..b8535bd 100644
--- a/automotive/vehicle/2.0/default/Android.mk
+++ b/automotive/vehicle/2.0/default/Android.mk
@@ -22,7 +22,6 @@
 include $(CLEAR_VARS)
 LOCAL_MODULE := $(vhal_v2_0)-manager-lib
 LOCAL_SRC_FILES := \
-    common/src/AccessControlConfigParser.cpp \
     common/src/SubscriptionManager.cpp \
     common/src/VehicleHalManager.cpp \
     common/src/VehicleObjectPool.cpp \
@@ -35,7 +34,6 @@
     $(LOCAL_PATH)/common/include
 
 LOCAL_SHARED_LIBRARIES := \
-    libbinder \
     libhidlbase \
     libhidltransport \
     libhwbinder \
@@ -89,7 +87,6 @@
 
 LOCAL_SHARED_LIBRARIES := \
     libbase \
-    libbinder \
     libhidlbase \
     libhidltransport \
     libhwbinder \
@@ -117,7 +114,6 @@
     $(vhal_v2_0)-manager-lib \
 
 LOCAL_SRC_FILES:= \
-    tests/AccessControlConfigParser_test.cpp \
     tests/RecurrentTimer_test.cpp \
     tests/SubscriptionManager_test.cpp \
     tests/VehicleHalManager_test.cpp \
@@ -125,7 +121,6 @@
     tests/VehiclePropConfigIndex_test.cpp \
 
 LOCAL_SHARED_LIBRARIES := \
-    libbinder \
     libhidlbase \
     libhidltransport \
     libhwbinder \
@@ -153,7 +148,6 @@
 
 LOCAL_SHARED_LIBRARIES := \
     libbase \
-    libbinder \
     libhidlbase \
     libhidltransport \
     libhwbinder \
diff --git a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/AccessControlConfigParser.h b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/AccessControlConfigParser.h
deleted file mode 100644
index 8ef6f5a..0000000
--- a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/AccessControlConfigParser.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef android_hardware_automotive_vehicle_V2_0_AccessControlConfigParser_H_
-#define android_hardware_automotive_vehicle_V2_0_AccessControlConfigParser_H_
-
-#include <string>
-#include <vector>
-#include <unordered_map>
-#include <list>
-
-#include <android/hardware/automotive/vehicle/2.0/types.h>
-
-namespace android {
-namespace hardware {
-namespace automotive {
-namespace vehicle {
-namespace V2_0 {
-
-struct PropertyAcl {
-    int32_t propId;
-    unsigned uid;
-    VehiclePropertyAccess access;
-};
-
-using PropertyAclMap = std::unordered_multimap<int32_t, PropertyAcl>;
-
-/**
- * Parser for per-property access control in vehicle HAL.
- *
- * It supports the following format:
- *   Set ALIAS_NAME UID
- *   {S,V}:0x0305   {ALIAS_NAME,UID}   {R,W,RW}
- *
- * ALIAS_NAME is just an alias for UID
- * S - for system properties (VehiclePropertyGroup::SYSTEM)
- * V - for vendor properties (VehiclePropertyGroup::VENDOR)
- *
- * Example:
- *
- *   Set AID_AUDIO  1004
- *   Set AID_MY_APP     10022
- *
- *   S:0x0305   AID_AUDIO   RW
- *   S:0x0305   10021       R
- *   V:0x0101   AID_MY_APP  R
- */
-class AccessControlConfigParser {
-public:
-    /**
-     * Creates an instance of AccessControlConfigParser
-     *
-     * @param properties - properties supported by HAL implementation
-     */
-    AccessControlConfigParser(const std::vector<int32_t>& properties);
-
-    /**
-     * Parses config content from given stream and writes results to
-     * propertyAclMap.
-     */
-    bool parseFromStream(std::istream* stream, PropertyAclMap* propertyAclMap);
-
-private:
-    bool processTokens(std::list<std::string>* tokens,
-                       PropertyAclMap* propertyAclMap);
-
-    bool parsePropertyGroup(char group,
-                            VehiclePropertyGroup* outPropertyGroup) const;
-
-    bool parsePropertyId(const std::string& strPropId,
-                                VehiclePropertyGroup propertyGroup,
-                                int32_t* outVehicleProperty) const;
-
-    bool parseUid(const std::string& strUid, unsigned* outUid) const;
-
-    bool parseAccess(const std::string& strAccess,
-                     VehiclePropertyAccess* outAccess) const;
-
-
-    std::string readNextToken(std::list<std::string>* tokens) const;
-
-    static bool parseInt(const char* strValue, int* outIntValue);
-    static void split(const std::string& line,
-                      std::list<std::string>* outTokens);
-
-private:
-    std::unordered_map<std::string, unsigned> mUidMap {};  // Contains UID
-    // aliases.
-
-    // Map property ids w/o TYPE and AREA to VehicleProperty.
-    std::unordered_map<int32_t, int32_t> mStrippedToVehiclePropertyMap;
-};
-
-}  // namespace V2_0
-}  // namespace vehicle
-}  // namespace automotive
-}  // namespace hardware
-}  // namespace android
-
-#endif // android_hardware_automotive_vehicle_V2_0_AccessControlConfigParser_H_
diff --git a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/SubscriptionManager.h b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/SubscriptionManager.h
index a808c66..fd59802 100644
--- a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/SubscriptionManager.h
+++ b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/SubscriptionManager.h
@@ -24,7 +24,7 @@
 
 #include <android/log.h>
 #include <hidl/HidlSupport.h>
-#include <hwbinder/IPCThreadState.h>
+#include <utils/SortedVector.h>
 
 #include <android/hardware/automotive/vehicle/2.0/IVehicle.h>
 
@@ -39,10 +39,8 @@
 
 class HalClient : public android::RefBase {
 public:
-    HalClient(const sp<IVehicleCallback> &callback,
-              int32_t pid,
-              int32_t uid)
-        : mCallback(callback), mPid(pid), mUid(uid) {}
+    HalClient(const sp<IVehicleCallback> &callback)
+        : mCallback(callback) {}
 
     virtual ~HalClient() {}
 public:
@@ -56,8 +54,6 @@
 
 private:
     const sp<IVehicleCallback> mCallback;
-    const int32_t mPid;
-    const int32_t mUid;
 
     std::map<int32_t, SubscribeOptions> mSubscriptions;
 };
diff --git a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehicleHalManager.h b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehicleHalManager.h
index b8ab309..1d45f4b 100644
--- a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehicleHalManager.h
+++ b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehicleHalManager.h
@@ -27,9 +27,7 @@
 #include <set>
 
 #include <android/hardware/automotive/vehicle/2.0/IVehicle.h>
-#include <hwbinder/IPCThreadState.h>
 
-#include "AccessControlConfigParser.h"
 #include "ConcurrentQueue.h"
 #include "SubscriptionManager.h"
 #include "VehicleHal.h"
@@ -42,11 +40,6 @@
 namespace vehicle {
 namespace V2_0 {
 
-struct Caller {
-    pid_t pid;
-    uid_t uid;
-};
-
 /**
  * This class is a thick proxy between IVehicle HIDL interface and vendor's implementation.
  *
@@ -99,14 +92,8 @@
 
     const VehiclePropConfig* getPropConfigOrNull(int32_t prop) const;
 
-    bool checkWritePermission(const VehiclePropConfig &config,
-                              const Caller& callee) const;
-    bool checkReadPermission(const VehiclePropConfig &config,
-                             const Caller& caller) const;
-    bool checkAcl(uid_t callerUid,
-                  int32_t propertyId,
-                  VehiclePropertyAccess requiredAccess) const;
-
+    bool checkWritePermission(const VehiclePropConfig &config) const;
+    bool checkReadPermission(const VehiclePropConfig &config) const;
     void onAllClientsUnsubscribed(int32_t propertyId);
 
     static bool isSubscribable(const VehiclePropConfig& config,
@@ -114,12 +101,6 @@
     static bool isSampleRateFixed(VehiclePropertyChangeMode mode);
     static float checkSampleRate(const VehiclePropConfig& config,
                                  float sampleRate);
-    static void readAndParseAclConfig(const char* filename,
-                                      AccessControlConfigParser* parser,
-                                      PropertyAclMap* outAclMap);
-
-    static Caller getCaller();
-
 private:
     VehicleHal* mHal;
     std::unique_ptr<VehiclePropConfigIndex> mConfigIndex;
@@ -130,7 +111,6 @@
     ConcurrentQueue<VehiclePropValuePtr> mEventQueue;
     BatchingConsumer<VehiclePropValuePtr> mBatchingConsumer;
     VehiclePropValuePool mValueObjectPool;
-    PropertyAclMap mPropertyAclMap;
 };
 
 }  // namespace V2_0
diff --git a/automotive/vehicle/2.0/default/common/src/AccessControlConfigParser.cpp b/automotive/vehicle/2.0/default/common/src/AccessControlConfigParser.cpp
deleted file mode 100644
index 6a3f8e5..0000000
--- a/automotive/vehicle/2.0/default/common/src/AccessControlConfigParser.cpp
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "automotive.vehicle@2.0-impl"
-
-#include "AccessControlConfigParser.h"
-#include "VehicleUtils.h"
-
-#include <fstream>
-#include <iostream>
-#include <sstream>
-
-#include <log/log.h>
-
-namespace android {
-namespace hardware {
-namespace automotive {
-namespace vehicle {
-namespace V2_0 {
-
-AccessControlConfigParser::AccessControlConfigParser(
-        const std::vector<int32_t>& properties) {
-    // Property Id in the config file doesn't include information about
-    // type and area. So we want to create a map from these kind of
-    // *stripped* properties to the whole VehicleProperty.
-    // We also want to filter out ACL to the properties that supported
-    // by concrete Vehicle HAL implementation.
-    for (auto prop : properties) {
-        auto strippedProp = prop
-                            & ~toInt(VehiclePropertyType::MASK)
-                            & ~toInt(VehicleArea::MASK);
-        mStrippedToVehiclePropertyMap.emplace(strippedProp, prop);
-    }
-}
-
-bool AccessControlConfigParser::parseFromStream(
-        std::istream* stream, PropertyAclMap* propertyAclMap) {
-    std::list<std::string> tokens;
-    std::string line;
-    int lineNo = 0;
-    bool warnings = false;
-    for (;std::getline(*stream, line); lineNo++) {
-        split(line, &tokens);
-        if (!processTokens(&tokens, propertyAclMap)) {
-            warnings = true;
-            ALOGW("Failed to parse line %d : %s", lineNo, line.c_str());
-        }
-    }
-    return !warnings;
-}
-
-
-bool AccessControlConfigParser::processTokens(std::list<std::string>* tokens,
-                                              PropertyAclMap* propertyAclMap) {
-    std::string token = readNextToken(tokens);
-    if (token.empty() || token[0] == '#') {   // Ignore comment.
-        return true;
-    }
-
-    if (token == "Set") {
-        std::string alias = readNextToken(tokens);
-        std::string strUid = readNextToken(tokens);
-        if (alias.empty() || strUid.empty()) {
-            ALOGW("Expected alias and UID must be specified");
-            return false;
-        }
-        int uid;
-        if (!parseInt(strUid.c_str(), &uid)) {
-            ALOGW("Invalid UID: %d", uid);
-        }
-        mUidMap.emplace(std::move(alias), uid);
-    } else if (token.size() > 2 && token[1] == ':') {
-        VehiclePropertyGroup propGroup;
-        if (!parsePropertyGroup(token[0], &propGroup)) {
-            return false;
-        }
-        std::string strUid = readNextToken(tokens);
-        std::string strAccess = readNextToken(tokens);
-        if (strUid.empty() || strAccess.empty()) {
-            ALOGW("Expected UID and access for property: %s",
-                  token.c_str());
-        }
-
-
-        PropertyAcl acl;
-        if (parsePropertyId(token.substr(2), propGroup, &acl.propId)
-            && parseUid(strUid, &acl.uid)
-            && parseAccess(strAccess, &acl.access)) {
-            propertyAclMap->emplace(acl.propId, std::move(acl));
-        } else {
-            return false;
-        }
-    } else {
-        ALOGW("Unexpected token: %s", token.c_str());
-        return false;
-    }
-
-    return true;
-}
-
-bool AccessControlConfigParser::parsePropertyGroup(
-        char group, VehiclePropertyGroup* outPropertyGroup) const {
-    switch (group) {
-        case 'S':  // Fall through.
-        case 's':
-            *outPropertyGroup = VehiclePropertyGroup::SYSTEM;
-            break;
-        case 'V':  // Fall through.
-        case 'v':
-            *outPropertyGroup = VehiclePropertyGroup::VENDOR;
-            break;
-        default:
-            ALOGW("Unexpected group: %c", group);
-            return false;
-    }
-    return true;
-}
-
-bool AccessControlConfigParser::parsePropertyId(
-        const std::string& strPropId,
-        VehiclePropertyGroup propertyGroup,
-        int32_t* outVehicleProperty) const {
-    int32_t propId;
-    if (!parseInt(strPropId.c_str(), &propId)) {
-        ALOGW("Failed to convert property id to integer: %s",
-              strPropId.c_str());
-        return false;
-    }
-    propId |= static_cast<int>(propertyGroup);
-    auto it = mStrippedToVehiclePropertyMap.find(propId);
-    if (it == mStrippedToVehiclePropertyMap.end()) {
-        ALOGW("Property Id not found or not supported: 0x%x", propId);
-        return false;
-    }
-    *outVehicleProperty = it->second;
-    return true;
-}
-
-bool AccessControlConfigParser::parseInt(const char* strValue,
-                                         int* outIntValue) {
-    char* end;
-    long num = std::strtol(strValue, &end, 0 /* auto detect base */);
-    bool success = *end == 0 && errno != ERANGE;
-    if (success) {
-        *outIntValue = static_cast<int>(num);
-    }
-
-    return success;
-}
-
-bool AccessControlConfigParser::parseUid(const std::string& strUid,
-                                         unsigned* outUid) const {
-    auto element = mUidMap.find(strUid);
-    if (element != mUidMap.end()) {
-        *outUid = element->second;
-    } else {
-        int val;
-        if (!parseInt(strUid.c_str(), &val)) {
-            ALOGW("Failed to convert UID '%s' to integer", strUid.c_str());
-            return false;
-        }
-        *outUid = static_cast<unsigned>(val);
-    }
-    return true;
-}
-
-bool AccessControlConfigParser::parseAccess(
-        const std::string& strAccess, VehiclePropertyAccess* outAccess) const {
-    if (strAccess.size() == 0 || strAccess.size() > 2) {
-        ALOGW("Unknown access mode '%s'", strAccess.c_str());
-        return false;
-    }
-    int32_t access = static_cast<int32_t>(VehiclePropertyAccess::NONE);
-    for (char c : strAccess) {
-        if (c == 'R' || c == 'r') {
-            access |= VehiclePropertyAccess::READ;
-        } else if (c == 'W' || c == 'w') {
-            access |= VehiclePropertyAccess::WRITE;
-        } else {
-            ALOGW("Unknown access mode: %c", c);
-            return false;
-        }
-    }
-    *outAccess = static_cast<VehiclePropertyAccess>(access);
-    return true;
-}
-
-void AccessControlConfigParser::split(const std::string& line,
-                                      std::list<std::string>* outTokens) {
-    outTokens->clear();
-    std::istringstream iss(line);
-
-    while (!iss.eof()) {
-        std::string token;
-        iss >> token;
-        outTokens->push_back(std::move(token));
-    }
-}
-
-std::string AccessControlConfigParser::readNextToken(
-        std::list<std::string>* tokens) const {
-    if (tokens->empty()) {
-        return "";
-    }
-
-    std::string token = tokens->front();
-    tokens->pop_front();
-    return token;
-}
-
-}  // namespace V2_0
-}  // namespace vehicle
-}  // namespace automotive
-}  // namespace hardware
-}  // namespace android
diff --git a/automotive/vehicle/2.0/default/common/src/SubscriptionManager.cpp b/automotive/vehicle/2.0/default/common/src/SubscriptionManager.cpp
index 4493a41..e0f3f31 100644
--- a/automotive/vehicle/2.0/default/common/src/SubscriptionManager.cpp
+++ b/automotive/vehicle/2.0/default/common/src/SubscriptionManager.cpp
@@ -232,10 +232,8 @@
                   __func__, callback.get(), res.description().c_str());
             return nullptr;
         }
-        IPCThreadState* self = IPCThreadState::self();
-        pid_t pid = self->getCallingPid();
-        uid_t uid = self->getCallingUid();
-        sp<HalClient> client = new HalClient(callback, pid, uid);
+
+        sp<HalClient> client = new HalClient(callback);
         mClients.emplace(callback, client);
         return client;
     } else {
diff --git a/automotive/vehicle/2.0/default/common/src/VehicleHalManager.cpp b/automotive/vehicle/2.0/default/common/src/VehicleHalManager.cpp
index 8906f6e..f452be8 100644
--- a/automotive/vehicle/2.0/default/common/src/VehicleHalManager.cpp
+++ b/automotive/vehicle/2.0/default/common/src/VehicleHalManager.cpp
@@ -18,10 +18,10 @@
 
 #include "VehicleHalManager.h"
 
+#include <cmath>
 #include <fstream>
 
 #include <android/log.h>
-#include <private/android_filesystem_config.h>
 
 #include "VehicleUtils.h"
 
@@ -84,7 +84,7 @@
         return Void();
     }
 
-    if (!checkReadPermission(*config, getCaller())) {
+    if (!checkReadPermission(*config)) {
         _hidl_cb(StatusCode::ACCESS_DENIED, kEmptyValue);
         return Void();
     }
@@ -105,7 +105,7 @@
         return StatusCode::INVALID_ARG;
     }
 
-    if (!checkWritePermission(*config, getCaller())) {
+    if (!checkWritePermission(*config)) {
         return StatusCode::ACCESS_DENIED;
     }
 
@@ -119,7 +119,6 @@
 Return<StatusCode> VehicleHalManager::subscribe(const sp<IVehicleCallback> &callback,
                                                 const hidl_vec<SubscribeOptions> &options) {
     hidl_vec<SubscribeOptions> verifiedOptions(options);
-    auto caller = getCaller();
     for (size_t i = 0; i < verifiedOptions.size(); i++) {
         SubscribeOptions& ops = verifiedOptions[i];
         auto prop = ops.propId;
@@ -136,10 +135,6 @@
             return StatusCode::INVALID_ARG;
         }
 
-        if (!checkAcl(caller.uid, config->prop, VehiclePropertyAccess::READ)) {
-            return StatusCode::ACCESS_DENIED;
-        }
-
         if (!isSubscribable(*config, ops.flags)) {
             ALOGE("Failed to subscribe: property 0x%x is not subscribable",
                   prop);
@@ -209,13 +204,6 @@
     for (const auto& config : supportedPropConfigs) {
         supportedProperties.push_back(config.prop);
     }
-
-    AccessControlConfigParser aclParser(supportedProperties);
-    const char* configs[] = { "/system/etc/vehicle_access.conf",
-                              "/vendor/etc/vehicle_access.conf" };
-    for (const char* filename : configs) {
-        readAndParseAclConfig(filename, &aclParser, &mPropertyAclMap);
-    }
 }
 
 VehicleHalManager::~VehicleHalManager() {
@@ -317,39 +305,22 @@
     return true;
 }
 
-bool VehicleHalManager::checkAcl(uid_t callerUid, int32_t propertyId,
-                                 VehiclePropertyAccess requiredAccess) const {
-    if (callerUid == AID_SYSTEM && isSystemProperty(propertyId)) {
-        return true;
-    }
-
-    auto range = mPropertyAclMap.equal_range(propertyId);
-    for (auto it = range.first; it != range.second; ++it) {
-        auto& acl = it->second;
-        if (acl.uid == callerUid && (acl.access & requiredAccess)) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool VehicleHalManager::checkWritePermission(const VehiclePropConfig &config,
-                                             const Caller& caller) const {
+bool VehicleHalManager::checkWritePermission(const VehiclePropConfig &config) const {
     if (!(config.access & VehiclePropertyAccess::WRITE)) {
         ALOGW("Property 0%x has no write access", config.prop);
         return false;
+    } else {
+        return true;
     }
-    return checkAcl(caller.uid, config.prop, VehiclePropertyAccess::WRITE);
 }
 
-bool VehicleHalManager::checkReadPermission(const VehiclePropConfig &config,
-                                            const Caller& caller) const {
+bool VehicleHalManager::checkReadPermission(const VehiclePropConfig &config) const {
     if (!(config.access & VehiclePropertyAccess::READ)) {
         ALOGW("Property 0%x has no read access", config.prop);
         return false;
+    } else {
+        return true;
     }
-
-    return checkAcl(caller.uid, config.prop, VehiclePropertyAccess::READ);
 }
 
 void VehicleHalManager::handlePropertySetEvent(const VehiclePropValue& value) {
@@ -366,26 +337,6 @@
            ? &mConfigIndex->getConfig(prop) : nullptr;
 }
 
-Caller VehicleHalManager::getCaller() {
-    Caller caller;
-    IPCThreadState* self = IPCThreadState::self();
-    caller.pid = self->getCallingPid();
-    caller.uid = self->getCallingUid();
-
-    return caller;
-}
-
-void VehicleHalManager::readAndParseAclConfig(const char* filename,
-                                              AccessControlConfigParser* parser,
-                                              PropertyAclMap* outAclMap) {
-    std::ifstream file(filename);
-    if (file.is_open()) {
-        ALOGI("Parsing file: %s", filename);
-        parser->parseFromStream(&file, outAclMap);
-        file.close();
-    }
-}
-
 void VehicleHalManager::onAllClientsUnsubscribed(int32_t propertyId) {
     mHal->unsubscribe(propertyId);
 }
diff --git a/automotive/vehicle/2.0/default/tests/AccessControlConfigParser_test.cpp b/automotive/vehicle/2.0/default/tests/AccessControlConfigParser_test.cpp
deleted file mode 100644
index d9611c0..0000000
--- a/automotive/vehicle/2.0/default/tests/AccessControlConfigParser_test.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gtest/gtest.h>
-#include <memory>
-#include <fstream>
-#include <unordered_set>
-
-#include "vhal_v2_0/AccessControlConfigParser.h"
-#include "vhal_v2_0/VehicleUtils.h"
-
-namespace android {
-namespace hardware {
-namespace automotive {
-namespace vehicle {
-namespace V2_0 {
-
-namespace {
-
-class AccessControlConfigParserTest : public ::testing::Test {
-protected:
-    void SetUp() override {
-        std::vector<int32_t> supportedProperties {
-            toInt(VehicleProperty::HVAC_FAN_SPEED),
-            toInt(VehicleProperty::HVAC_FAN_DIRECTION),
-        };
-        parser.reset(new AccessControlConfigParser(supportedProperties));
-    }
-public:
-    PropertyAclMap aclMap;
-    std::unique_ptr<AccessControlConfigParser> parser;
-};
-
-TEST_F(AccessControlConfigParserTest, basicParsing) {
-    std::stringstream file;
-    file << "S:0x0500 1000 RW" << std::endl;
-
-    ASSERT_TRUE(parser->parseFromStream(&file, &aclMap));
-
-    ASSERT_EQ(1u, aclMap.size());
-    auto it = aclMap.find(toInt(VehicleProperty::HVAC_FAN_SPEED));
-    ASSERT_NE(aclMap.end(), it);
-    ASSERT_EQ(VehiclePropertyAccess::READ_WRITE, it->second.access);
-    ASSERT_EQ(toInt(VehicleProperty::HVAC_FAN_SPEED), it->second.propId);
-    ASSERT_EQ(1000u, it->second.uid);
-}
-
-TEST_F(AccessControlConfigParserTest, multipleUids) {
-    std::stringstream file;
-    file << "Set AID_AUDIO 1004" << std::endl
-            << "Set AID_SYSTEM 1000" << std::endl
-            << "S:0x0500 AID_SYSTEM RW" << std::endl
-            << "S:0x0500 AID_AUDIO RW" << std::endl
-            << "S:0x0500 0xbeef R" << std::endl;  // Read-only.
-
-    std::unordered_set<unsigned> expectedUids {1000, 1004, 0xbeef};
-
-    ASSERT_TRUE(parser->parseFromStream(&file, &aclMap));
-
-    auto range = aclMap.equal_range(toInt(VehicleProperty::HVAC_FAN_SPEED));
-    for (auto it = range.first; it != range.second; ++it) {
-        auto& acl = it->second;
-
-        ASSERT_EQ(1u, expectedUids.count(acl.uid))
-                << " uid: " << std::hex << acl.uid;
-
-        if (acl.uid == 0xbeef) {
-            ASSERT_EQ(VehiclePropertyAccess::READ, acl.access);
-        } else {
-            ASSERT_EQ(VehiclePropertyAccess::READ_WRITE, acl.access);
-        }
-    }
-}
-
-TEST_F(AccessControlConfigParserTest, fileContainsJunk) {
-    std::stringstream file;
-    file << "This string will be ignored with warning in the log" << std::endl
-         << "# However comments are quit legitimate" << std::endl
-         << "S:0x0500 0xbeef R # YAY" << std::endl;
-
-    ASSERT_FALSE(parser->parseFromStream(&file, &aclMap));
-
-    ASSERT_EQ(1u, aclMap.size());
-    auto it = aclMap.find(toInt(VehicleProperty::HVAC_FAN_SPEED));
-    ASSERT_NE(aclMap.end(), it);
-    ASSERT_EQ(VehiclePropertyAccess::READ, it->second.access);
-    ASSERT_EQ(toInt(VehicleProperty::HVAC_FAN_SPEED), it->second.propId);
-    ASSERT_EQ(0xBEEFu, it->second.uid);
-}
-
-TEST_F(AccessControlConfigParserTest, badIntegerFormat) {
-    std::stringstream file;
-    file << "S:0x0500 A12 RW " << std::endl;
-
-    ASSERT_FALSE(parser->parseFromStream(&file, &aclMap));
-    ASSERT_EQ(0u, aclMap.size());
-}
-
-TEST_F(AccessControlConfigParserTest, ignoreNotSupportedProperties) {
-    std::stringstream file;
-    file << "S:0x0666 1000 RW " << std::endl;
-
-    ASSERT_FALSE(parser->parseFromStream(&file, &aclMap));
-    ASSERT_EQ(0u, aclMap.size());
-}
-
-TEST_F(AccessControlConfigParserTest, multipleCalls) {
-    std::stringstream configFile;
-    configFile << "S:0x0500 1000 RW" << std::endl;
-
-    ASSERT_TRUE(parser->parseFromStream(&configFile, &aclMap));
-    ASSERT_EQ(1u, aclMap.size());
-
-    std::stringstream configFile2;
-    configFile2 << "S:0x0501 1004 RW" << std::endl;
-    ASSERT_TRUE(parser->parseFromStream(&configFile2, &aclMap));
-    ASSERT_EQ(2u, aclMap.size());
-
-    auto it = aclMap.find(toInt(VehicleProperty::HVAC_FAN_SPEED));
-    ASSERT_NE(aclMap.end(), it);
-    ASSERT_EQ(VehiclePropertyAccess::READ_WRITE, it->second.access);
-    ASSERT_EQ(toInt(VehicleProperty::HVAC_FAN_SPEED), it->second.propId);
-    ASSERT_EQ(1000u, it->second.uid);
-
-    it = aclMap.find(toInt(VehicleProperty::HVAC_FAN_DIRECTION));
-    ASSERT_NE(aclMap.end(), it);
-    ASSERT_EQ(VehiclePropertyAccess::READ_WRITE, it->second.access);
-    ASSERT_EQ(toInt(VehicleProperty::HVAC_FAN_DIRECTION), it->second.propId);
-    ASSERT_EQ(1004u, it->second.uid);
-}
-
-
-}  // namespace anonymous
-
-}  // namespace V2_0
-}  // namespace vehicle
-}  // namespace automotive
-}  // namespace hardware
-}  // namespace android
diff --git a/automotive/vehicle/2.0/default/tests/VehicleHalManager_test.cpp b/automotive/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
index b5cdf5c..04335b5 100644
--- a/automotive/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
+++ b/automotive/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
@@ -452,8 +452,8 @@
     HalClientVector clients;
     sp<IVehicleCallback> callback1 = new MockedVehicleCallback();
 
-    sp<HalClient> c1 = new HalClient(callback1, 10, 20);
-    sp<HalClient> c2 = new HalClient(callback1, 10, 20);
+    sp<HalClient> c1 = new HalClient(callback1);
+    sp<HalClient> c2 = new HalClient(callback1);
 
     clients.addOrUpdate(c1);
     clients.addOrUpdate(c1);
diff --git a/automotive/vehicle/2.1/default/Android.mk b/automotive/vehicle/2.1/default/Android.mk
index 3075956..51cb146 100644
--- a/automotive/vehicle/2.1/default/Android.mk
+++ b/automotive/vehicle/2.1/default/Android.mk
@@ -33,7 +33,6 @@
     $(LOCAL_PATH)/common/include
 
 LOCAL_SHARED_LIBRARIES := \
-    libbinder \
     libhidlbase \
     libhidltransport \
     libhwbinder \
@@ -71,7 +70,6 @@
 
 LOCAL_SHARED_LIBRARIES := \
     libbase \
-    libbinder \
     libhidlbase \
     libhidltransport \
     libhwbinder \
@@ -107,7 +105,6 @@
 
 LOCAL_SHARED_LIBRARIES := \
     libbase \
-    libbinder \
     libhidlbase \
     libhidltransport \
     libhwbinder \
diff --git a/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp b/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
index 9a4efae..d699f21 100644
--- a/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
+++ b/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
@@ -23,9 +23,8 @@
 #include <hardware/bluetooth.h>
 #include <utils/Log.h>
 
+#include <VtsHalHidlTargetCallbackBase.h>
 #include <VtsHalHidlTargetTestBase.h>
-#include <condition_variable>
-#include <mutex>
 #include <queue>
 
 using ::android::hardware::bluetooth::V1_0::IBluetoothHci;
@@ -92,6 +91,11 @@
 #define ACL_BROADCAST_ACTIVE_SLAVE (0x1 << 4)
 #define ACL_PACKET_BOUNDARY_COMPLETE (0x3 << 6)
 
+constexpr char kCallbackNameAclEventReceived[] = "aclDataReceived";
+constexpr char kCallbackNameHciEventReceived[] = "hciEventReceived";
+constexpr char kCallbackNameInitializationComplete[] = "initializationComplete";
+constexpr char kCallbackNameScoEventReceived[] = "scoDataReceived";
+
 class ThroughputLogger {
  public:
   ThroughputLogger(std::string task)
@@ -121,7 +125,8 @@
  public:
   virtual void SetUp() override {
     // currently test passthrough mode only
-    bluetooth = ::testing::VtsHalHidlTargetTestBase::getService<IBluetoothHci>();
+    bluetooth =
+        ::testing::VtsHalHidlTargetTestBase::getService<IBluetoothHci>();
     ASSERT_NE(bluetooth, nullptr);
     ALOGI("%s: getService() for bluetooth is %s", __func__,
           bluetooth->isRemote() ? "remote" : "local");
@@ -135,10 +140,6 @@
     max_sco_data_packets = 0;
 
     initialized = false;
-    initialized_count = 0;
-    event_count = 0;
-    acl_count = 0;
-    sco_count = 0;
     event_cb_count = 0;
     acl_cb_count = 0;
     sco_cb_count = 0;
@@ -146,7 +147,18 @@
     ASSERT_EQ(initialized, false);
     bluetooth->initialize(bluetooth_cb);
 
-    wait_for_init_callback();
+    bluetooth_cb->SetWaitTimeout(kCallbackNameInitializationComplete,
+                                 WAIT_FOR_INIT_TIMEOUT);
+    bluetooth_cb->SetWaitTimeout(kCallbackNameHciEventReceived,
+                                 WAIT_FOR_HCI_EVENT_TIMEOUT);
+    bluetooth_cb->SetWaitTimeout(kCallbackNameAclEventReceived,
+                                 WAIT_FOR_ACL_DATA_TIMEOUT);
+    bluetooth_cb->SetWaitTimeout(kCallbackNameScoEventReceived,
+                                 WAIT_FOR_SCO_DATA_TIMEOUT);
+
+    EXPECT_TRUE(
+        bluetooth_cb->WaitForCallback(kCallbackNameInitializationComplete)
+            .no_timeout);
 
     ASSERT_EQ(initialized, true);
   }
@@ -171,82 +183,10 @@
   void wait_for_command_complete_event(hidl_vec<uint8_t> cmd);
   int wait_for_completed_packets_event(uint16_t handle);
 
-  // Inform the test about the initialization callback
-  inline void notify_initialized() {
-    std::unique_lock<std::mutex> lock(initialized_mutex);
-    initialized_count++;
-    initialized_condition.notify_one();
-  }
-
-  // Test code calls this function to wait for the init callback
-  inline void wait_for_init_callback() {
-    std::unique_lock<std::mutex> lock(initialized_mutex);
-
-    auto start_time = std::chrono::steady_clock::now();
-    while (initialized_count == 0)
-      if (initialized_condition.wait_until(lock,
-                                     start_time + WAIT_FOR_INIT_TIMEOUT) ==
-          std::cv_status::timeout)
-        return;
-    initialized_count--;
-  }
-
-  // Inform the test about an event callback
-  inline void notify_event_received() {
-    std::unique_lock<std::mutex> lock(event_mutex);
-    event_count++;
-    event_condition.notify_one();
-  }
-
-  // Test code calls this function to wait for an event callback
-  inline void wait_for_event() {
-    std::unique_lock<std::mutex> lock(event_mutex);
-
-    auto start_time = std::chrono::steady_clock::now();
-    while (event_count == 0)
-      if (event_condition.wait_until(lock,
-                                     start_time + WAIT_FOR_HCI_EVENT_TIMEOUT) ==
-          std::cv_status::timeout)
-        return;
-    event_count--;
-  }
-
-  // Inform the test about an acl data callback
-  inline void notify_acl_data_received() {
-    std::unique_lock<std::mutex> lock(acl_mutex);
-    acl_count++;
-    acl_condition.notify_one();
-  }
-
-  // Test code calls this function to wait for an acl data callback
-  inline void wait_for_acl() {
-    std::unique_lock<std::mutex> lock(acl_mutex);
-
-    while (acl_count == 0)
-      acl_condition.wait_until(
-          lock, std::chrono::steady_clock::now() + WAIT_FOR_ACL_DATA_TIMEOUT);
-    acl_count--;
-  }
-
-  // Inform the test about a sco data callback
-  inline void notify_sco_data_received() {
-    std::unique_lock<std::mutex> lock(sco_mutex);
-    sco_count++;
-    sco_condition.notify_one();
-  }
-
-  // Test code calls this function to wait for a sco data callback
-  inline void wait_for_sco() {
-    std::unique_lock<std::mutex> lock(sco_mutex);
-
-    while (sco_count == 0)
-      sco_condition.wait_until(
-          lock, std::chrono::steady_clock::now() + WAIT_FOR_SCO_DATA_TIMEOUT);
-    sco_count--;
-  }
-
   // A simple test implementation of BluetoothHciCallbacks.
-  class BluetoothHciCallbacks : public IBluetoothHciCallbacks {
+  class BluetoothHciCallbacks
+      : public ::testing::VtsHalHidlTargetCallbackBase<BluetoothHidlTest>,
+        public IBluetoothHciCallbacks {
     BluetoothHidlTest& parent_;
 
    public:
@@ -256,7 +196,7 @@
 
     Return<void> initializationComplete(Status status) override {
       parent_.initialized = (status == Status::SUCCESS);
-      parent_.notify_initialized();
+      NotifyFromCallback(kCallbackNameInitializationComplete);
       ALOGV("%s (status = %d)", __func__, static_cast<int>(status));
       return Void();
     };
@@ -265,7 +205,7 @@
         const ::android::hardware::hidl_vec<uint8_t>& event) override {
       parent_.event_cb_count++;
       parent_.event_queue.push(event);
-      parent_.notify_event_received();
+      NotifyFromCallback(kCallbackNameHciEventReceived);
       ALOGV("Event received (length = %d)", static_cast<int>(event.size()));
       return Void();
     };
@@ -274,7 +214,7 @@
         const ::android::hardware::hidl_vec<uint8_t>& data) override {
       parent_.acl_cb_count++;
       parent_.acl_queue.push(data);
-      parent_.notify_acl_data_received();
+      NotifyFromCallback(kCallbackNameAclEventReceived);
       return Void();
     };
 
@@ -282,13 +222,13 @@
         const ::android::hardware::hidl_vec<uint8_t>& data) override {
       parent_.sco_cb_count++;
       parent_.sco_queue.push(data);
-      parent_.notify_sco_data_received();
+      NotifyFromCallback(kCallbackNameScoEventReceived);
       return Void();
     };
   };
 
   sp<IBluetoothHci> bluetooth;
-  sp<IBluetoothHciCallbacks> bluetooth_cb;
+  sp<BluetoothHciCallbacks> bluetooth_cb;
   std::queue<hidl_vec<uint8_t>> event_queue;
   std::queue<hidl_vec<uint8_t>> acl_queue;
   std::queue<hidl_vec<uint8_t>> sco_queue;
@@ -303,20 +243,6 @@
   int max_sco_data_packet_length;
   int max_acl_data_packets;
   int max_sco_data_packets;
-
- private:
-  std::mutex initialized_mutex;
-  std::mutex event_mutex;
-  std::mutex sco_mutex;
-  std::mutex acl_mutex;
-  std::condition_variable initialized_condition;
-  std::condition_variable event_condition;
-  std::condition_variable sco_condition;
-  std::condition_variable acl_condition;
-  int initialized_count;
-  int event_count;
-  int sco_count;
-  int acl_count;
 };
 
 // A class for test environment setup (kept since this file is a template).
@@ -334,11 +260,12 @@
   int status_event_count = 0;
   hidl_vec<uint8_t> event;
   do {
-    wait_for_event();
-    EXPECT_LT(static_cast<size_t>(0), event_queue.size());
-    if (event_queue.size() == 0) {
-      event.resize(0);
-      break;
+      EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+                      .no_timeout);
+      EXPECT_LT(static_cast<size_t>(0), event_queue.size());
+      if (event_queue.size() == 0) {
+          event.resize(0);
+          break;
     }
     event = event_queue.front();
     event_queue.pop();
@@ -366,7 +293,8 @@
   hidl_vec<uint8_t> cmd = COMMAND_HCI_READ_BUFFER_SIZE;
   bluetooth->sendHciCommand(cmd);
 
-  wait_for_event();
+  EXPECT_TRUE(
+      bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived).no_timeout);
 
   EXPECT_LT(static_cast<size_t>(0), event_queue.size());
   if (event_queue.size() == 0) return;
@@ -420,7 +348,8 @@
     bluetooth->sendHciCommand(cmd);
 
     // Check the loopback of the HCI packet
-    wait_for_event();
+    EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+                    .no_timeout);
     hidl_vec<uint8_t> event = event_queue.front();
     event_queue.pop();
     size_t compare_length =
@@ -456,7 +385,8 @@
     bluetooth->sendScoData(sco_vector);
 
     // Check the loopback of the SCO packet
-    wait_for_sco();
+    EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameScoEventReceived)
+                    .no_timeout);
     hidl_vec<uint8_t> sco_loopback = sco_queue.front();
     sco_queue.pop();
 
@@ -501,7 +431,8 @@
     bluetooth->sendAclData(acl_vector);
 
     // Check the loopback of the ACL packet
-    wait_for_acl();
+    EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameAclEventReceived)
+                    .no_timeout);
     hidl_vec<uint8_t> acl_loopback = acl_queue.front();
     acl_queue.pop();
 
@@ -527,19 +458,20 @@
 
 // Return the number of completed packets reported by the controller.
 int BluetoothHidlTest::wait_for_completed_packets_event(uint16_t handle) {
-  wait_for_event();
-  int packets_processed = 0;
-  while (event_queue.size() > 0) {
-    hidl_vec<uint8_t> event = event_queue.front();
-    event_queue.pop();
+    EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+                    .no_timeout);
+    int packets_processed = 0;
+    while (event_queue.size() > 0) {
+        hidl_vec<uint8_t> event = event_queue.front();
+        event_queue.pop();
 
-    EXPECT_EQ(EVENT_NUMBER_OF_COMPLETED_PACKETS, event[EVENT_CODE_BYTE]);
-    EXPECT_EQ(1, event[EVENT_NUMBER_OF_COMPLETED_PACKETS_NUM_HANDLES]);
+        EXPECT_EQ(EVENT_NUMBER_OF_COMPLETED_PACKETS, event[EVENT_CODE_BYTE]);
+        EXPECT_EQ(1, event[EVENT_NUMBER_OF_COMPLETED_PACKETS_NUM_HANDLES]);
 
-    uint16_t event_handle = event[3] + (event[4] << 8);
-    EXPECT_EQ(handle, event_handle);
+        uint16_t event_handle = event[3] + (event[4] << 8);
+        EXPECT_EQ(handle, event_handle);
 
-    packets_processed += event[5] + (event[6] << 8);
+        packets_processed += event[5] + (event[6] << 8);
   }
   return packets_processed;
 }
@@ -554,32 +486,34 @@
   int connection_event_count = 0;
   hidl_vec<uint8_t> event;
   do {
-    wait_for_event();
-    event = event_queue.front();
-    event_queue.pop();
-    EXPECT_GT(event.size(),
-              static_cast<size_t>(EVENT_COMMAND_COMPLETE_STATUS_BYTE));
-    if (event[EVENT_CODE_BYTE] == EVENT_CONNECTION_COMPLETE) {
+      EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+                      .no_timeout);
+      event = event_queue.front();
+      event_queue.pop();
       EXPECT_GT(event.size(),
-                static_cast<size_t>(EVENT_CONNECTION_COMPLETE_TYPE));
-      EXPECT_EQ(event[EVENT_LENGTH_BYTE],
-                EVENT_CONNECTION_COMPLETE_PARAM_LENGTH);
-      uint8_t connection_type = event[EVENT_CONNECTION_COMPLETE_TYPE];
+                static_cast<size_t>(EVENT_COMMAND_COMPLETE_STATUS_BYTE));
+      if (event[EVENT_CODE_BYTE] == EVENT_CONNECTION_COMPLETE) {
+          EXPECT_GT(event.size(),
+                    static_cast<size_t>(EVENT_CONNECTION_COMPLETE_TYPE));
+          EXPECT_EQ(event[EVENT_LENGTH_BYTE],
+                    EVENT_CONNECTION_COMPLETE_PARAM_LENGTH);
+          uint8_t connection_type = event[EVENT_CONNECTION_COMPLETE_TYPE];
 
-      EXPECT_TRUE(connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO ||
-                  connection_type == EVENT_CONNECTION_COMPLETE_TYPE_ACL);
+          EXPECT_TRUE(connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO ||
+                      connection_type == EVENT_CONNECTION_COMPLETE_TYPE_ACL);
 
-      // Save handles
-      uint16_t handle = event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE] |
-                        event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE + 1] << 8;
-      if (connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO)
-        sco_handles.push_back(handle);
-      else
-        acl_handles.push_back(handle);
+          // Save handles
+          uint16_t handle = event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE] |
+                            event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE + 1]
+                                << 8;
+          if (connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO)
+              sco_handles.push_back(handle);
+          else
+              acl_handles.push_back(handle);
 
-      ALOGD("Connect complete type = %d handle = %d",
-            event[EVENT_CONNECTION_COMPLETE_TYPE], handle);
-      connection_event_count++;
+          ALOGD("Connect complete type = %d handle = %d",
+                event[EVENT_CONNECTION_COMPLETE_TYPE], handle);
+          connection_event_count++;
     }
   } while (event[EVENT_CODE_BYTE] == EVENT_CONNECTION_COMPLETE);
 
@@ -592,7 +526,7 @@
 }
 
 // Empty test: Initialize()/Close() are called in SetUp()/TearDown().
-TEST_F(BluetoothHidlTest, InitializeAndClose) { }
+TEST_F(BluetoothHidlTest, InitializeAndClose) {}
 
 // Send an HCI Reset with sendHciCommand and wait for a command complete event.
 TEST_F(BluetoothHidlTest, HciReset) {
@@ -607,7 +541,8 @@
   hidl_vec<uint8_t> cmd = COMMAND_HCI_READ_LOCAL_VERSION_INFORMATION;
   bluetooth->sendHciCommand(cmd);
 
-  wait_for_event();
+  EXPECT_TRUE(
+      bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived).no_timeout);
 
   hidl_vec<uint8_t> event = event_queue.front();
   event_queue.pop();
@@ -627,7 +562,8 @@
   hidl_vec<uint8_t> cmd = COMMAND_HCI_SHOULD_BE_UNKNOWN;
   bluetooth->sendHciCommand(cmd);
 
-  wait_for_event();
+  EXPECT_TRUE(
+      bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived).no_timeout);
 
   hidl_vec<uint8_t> event = event_queue.front();
   event_queue.pop();
diff --git a/camera/device/1.0/ICameraDevice.hal b/camera/device/1.0/ICameraDevice.hal
index 52d6cf0..d4aa8cc 100644
--- a/camera/device/1.0/ICameraDevice.hal
+++ b/camera/device/1.0/ICameraDevice.hal
@@ -328,6 +328,20 @@
     releaseRecordingFrameHandle(MemoryId memId, uint32_t bufferIndex, handle frame);
 
     /**
+     * Release a batch of record frames previously returned by CAMERA_MSG_VIDEO_FRAME
+     * in handleCallbackTimestampBatch.
+     *
+     * It is camera HAL client's responsibility to release video recording
+     * frames sent out by the camera HAL before the camera HAL receives a call
+     * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
+     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
+     * responsibility to manage the life-cycle of the video recording frames.
+     *
+     * @param batch A batch of recording frames to be released by camera HAL.
+     */
+    releaseRecordingFrameHandleBatch(vec<VideoFrameMessage> batch);
+
+    /**
      * Start auto focus.
      *
      * The notification callback routine is called with
diff --git a/camera/device/1.0/ICameraDeviceCallback.hal b/camera/device/1.0/ICameraDeviceCallback.hal
index 1b0db24..1dfcd80 100644
--- a/camera/device/1.0/ICameraDeviceCallback.hal
+++ b/camera/device/1.0/ICameraDeviceCallback.hal
@@ -92,10 +92,24 @@
      * @param timestamp The time this buffer was captured by the camera, in
      *     nanoseconds.
      *
-     * @return frameId a frame ID to be used with releaseRecordingFrameId later
-     *
      */
     handleCallbackTimestamp(DataCallbackMsg msgType, handle frameData, MemoryId data,
             uint32_t bufferIndex, int64_t timestamp);
 
+    /**
+     * Send a batch of image data buffer to the camera service, with timestamps
+     *
+     * This callback can be used to send multiple frames to camera framework in one callback, which
+     * reduce number of callbacks in performance intensive use cases, such as high speed video
+     * recording. The HAL must not mix use of this method with handleCallbackTimestamp in one
+     * recording session (between startRecording and stopRecording)
+     *
+     * @param msgType The kind of image buffer data this call represents.
+     * @param batch a vector messages. Each message contains a image buffer and a timestamp. The
+     *     messages must be ordered in time from lower index to higher index, so that timestamp of
+     *     i-th message is always smaller than i+1-th message.
+     *
+     */
+    handleCallbackTimestampBatch(DataCallbackMsg msgType, vec<HandleTimestampMessage> batch);
+
 };
diff --git a/camera/device/1.0/default/Android.bp b/camera/device/1.0/default/Android.bp
index 5688fc1..af94b0f 100644
--- a/camera/device/1.0/default/Android.bp
+++ b/camera/device/1.0/default/Android.bp
@@ -7,6 +7,7 @@
     ],
     shared_libs: [
         "libhidlbase",
+        "libhidlmemory",
         "libhidltransport",
         "libhwbinder",
         "libutils",
@@ -14,12 +15,13 @@
         "android.hardware.camera.common@1.0",
         "android.hardware.graphics.allocator@2.0",
         "android.hardware.graphics.common@1.0",
+        "android.hidl.allocator@1.0",
         "android.hidl.base@1.0",
+        "android.hidl.memory@1.0",
         "libcutils",
         "liblog",
         "libhardware",
         "libcamera_metadata",
-        "libbinder",
     ],
     static_libs: [
         "android.hardware.camera.common@1.0-helper"
diff --git a/camera/device/1.0/default/CameraDevice.cpp b/camera/device/1.0/default/CameraDevice.cpp
index 819525b..877c6e7 100644
--- a/camera/device/1.0/default/CameraDevice.cpp
+++ b/camera/device/1.0/default/CameraDevice.cpp
@@ -18,6 +18,7 @@
 #include <utils/Log.h>
 #include <hardware/camera.h>
 #include <hardware/gralloc1.h>
+#include <hidlmemory/mapping.h>
 #include <utils/Trace.h>
 
 #include "CameraDevice_1_0.h"
@@ -102,6 +103,12 @@
                 __FUNCTION__, mCameraId.c_str());
         mInitFail = true;
     }
+
+    mAshmemAllocator = IAllocator::getService("ashmem");
+    if (mAshmemAllocator == nullptr) {
+        ALOGI("%s: cannot get ashmemAllocator", __FUNCTION__);
+        mInitFail = true;
+    }
 }
 
 CameraDevice::~CameraDevice() {
@@ -289,35 +296,66 @@
     return getStatusT(s);
 }
 
-CameraDevice::CameraHeapMemory::CameraHeapMemory(int fd, size_t buf_size, uint_t num_buffers) :
+CameraDevice::CameraHeapMemory::CameraHeapMemory(
+    int fd, size_t buf_size, uint_t num_buffers) :
         mBufSize(buf_size),
         mNumBufs(num_buffers) {
-    mHeap = new MemoryHeapBase(fd, buf_size * num_buffers);
+    mHidlHandle = native_handle_create(1,0);
+    mHidlHandle->data[0] = fcntl(fd, F_DUPFD_CLOEXEC, 0);
+    const size_t pagesize = getpagesize();
+    size_t size = ((buf_size * num_buffers + pagesize-1) & ~(pagesize-1));
+    mHidlHeap = hidl_memory("ashmem", mHidlHandle, size);
     commonInitialization();
 }
 
-CameraDevice::CameraHeapMemory::CameraHeapMemory(size_t buf_size, uint_t num_buffers) :
+CameraDevice::CameraHeapMemory::CameraHeapMemory(
+    sp<IAllocator> ashmemAllocator,
+    size_t buf_size, uint_t num_buffers) :
         mBufSize(buf_size),
         mNumBufs(num_buffers) {
-    mHeap = new MemoryHeapBase(buf_size * num_buffers);
+    const size_t pagesize = getpagesize();
+    size_t size = ((buf_size * num_buffers + pagesize-1) & ~(pagesize-1));
+    ashmemAllocator->allocate(size,
+        [&](bool success, const hidl_memory& mem) {
+            if (!success) {
+                ALOGE("%s: allocating ashmem of %zu bytes failed!",
+                        __FUNCTION__, buf_size * num_buffers);
+                return;
+            }
+            mHidlHandle = native_handle_clone(mem.handle());
+            mHidlHeap = hidl_memory("ashmem", mHidlHandle, size);
+        });
+
     commonInitialization();
 }
 
 void CameraDevice::CameraHeapMemory::commonInitialization() {
-    handle.data = mHeap->base();
+    mHidlHeapMemory = mapMemory(mHidlHeap);
+    if (mHidlHeapMemory == nullptr) {
+        ALOGE("%s: memory map failed!", __FUNCTION__);
+        native_handle_close(mHidlHandle); // close FD for the shared memory
+        native_handle_delete(mHidlHandle);
+        mHidlHeap = hidl_memory();
+        mHidlHandle = nullptr;
+        return;
+    }
+    mHidlHeapMemData = mHidlHeapMemory->getPointer();
+    handle.data = mHidlHeapMemData;
     handle.size = mBufSize * mNumBufs;
     handle.handle = this;
-
-    mBuffers = new sp<MemoryBase>[mNumBufs];
-    for (uint_t i = 0; i < mNumBufs; i++) {
-        mBuffers[i] = new MemoryBase(mHeap, i * mBufSize, mBufSize);
-    }
-
     handle.release = sPutMemory;
 }
 
 CameraDevice::CameraHeapMemory::~CameraHeapMemory() {
-    delete [] mBuffers;
+    if (mHidlHeapMemory != nullptr) {
+        mHidlHeapMemData = nullptr;
+        mHidlHeapMemory.clear(); // The destructor will trigger munmap
+    }
+
+    if (mHidlHandle) {
+        native_handle_close(mHidlHandle); // close FD for the shared memory
+        native_handle_delete(mHidlHandle);
+    }
 }
 
 // shared memory methods
@@ -330,22 +368,13 @@
     }
 
     CameraHeapMemory* mem;
-    native_handle_t* handle = native_handle_create(1,0);
-
-    if (handle == nullptr) {
-        ALOGE("%s: native_handle_create failed!", __FUNCTION__);
-        return nullptr;
-    }
-
     if (fd < 0) {
-        mem = new CameraHeapMemory(buf_size, num_bufs);
+        mem = new CameraHeapMemory(object->mAshmemAllocator, buf_size, num_bufs);
     } else {
         mem = new CameraHeapMemory(fd, buf_size, num_bufs);
     }
-    handle->data[0] = mem->mHeap->getHeapID();
     mem->incStrong(mem);
-
-    hidl_handle hidlHandle = handle;
+    hidl_handle hidlHandle = mem->mHidlHandle;
     MemoryId id = object->mDeviceCallback->registerMemory(hidlHandle, buf_size, num_bufs);
     mem->handle.mId = id;
     if (object->mMemoryMap.count(id) != 0) {
@@ -353,7 +382,6 @@
     }
     object->mMemoryMap[id] = mem;
     mem->handle.mDevice = object;
-    native_handle_delete(handle);
     return &mem->handle;
 }
 
@@ -420,6 +448,39 @@
     }
 }
 
+void CameraDevice::handleCallbackTimestamp(
+        nsecs_t timestamp, int32_t msg_type,
+        MemoryId memId , unsigned index, native_handle_t* handle) {
+    uint32_t batchSize = 0;
+    {
+        Mutex::Autolock _l(mBatchLock);
+        batchSize = mBatchSize;
+    }
+
+    if (batchSize == 0) { // non-batch mode
+        mDeviceCallback->handleCallbackTimestamp(
+                (DataCallbackMsg) msg_type, handle, memId, index, timestamp);
+    } else { // batch mode
+        Mutex::Autolock _l(mBatchLock);
+        size_t inflightSize = mInflightBatch.size();
+        if (inflightSize == 0) {
+            mBatchMsgType = msg_type;
+        } else if (mBatchMsgType != msg_type) {
+            ALOGE("%s: msg_type change (from %d to %d) is not supported!",
+                    __FUNCTION__, mBatchMsgType, msg_type);
+            return;
+        }
+        mInflightBatch.push_back({handle, memId, index, timestamp});
+
+        // Send batched frames to camera framework
+        if (mInflightBatch.size() >= batchSize) {
+            mDeviceCallback->handleCallbackTimestampBatch(
+                    (DataCallbackMsg) mBatchMsgType, mInflightBatch);
+            mInflightBatch.clear();
+        }
+    }
+}
+
 void CameraDevice::sDataCbTimestamp(nsecs_t timestamp, int32_t msg_type,
         const camera_memory_t *data, unsigned index, void *user) {
     ALOGV("%s", __FUNCTION__);
@@ -438,7 +499,7 @@
     if (object->mMetadataMode) {
         if (mem->mBufSize == sizeof(VideoNativeHandleMetadata)) {
             VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*)
-                    mem->mBuffers[index]->pointer();
+                    ((uint8_t*) mem->mHidlHeapMemData + index * mem->mBufSize);
             if (md->eType == VideoNativeHandleMetadata::kMetadataBufferTypeNativeHandleSource) {
                 handle = md->pHandle;
             }
@@ -450,8 +511,7 @@
             object->mDeviceCallback->dataCallbackTimestamp(
                     (DataCallbackMsg) msg_type, mem->handle.mId, index, timestamp);
         } else {
-            object->mDeviceCallback->handleCallbackTimestamp(
-                    (DataCallbackMsg) msg_type, handle, mem->handle.mId, index, timestamp);
+            object->handleCallbackTimestamp(timestamp, msg_type, mem->handle.mId, index, handle);
         }
     }
 }
@@ -769,27 +829,12 @@
     }
     if (mDevice->ops->release_recording_frame) {
         CameraHeapMemory* camMemory = mMemoryMap.at(memId);
-        sp<MemoryHeapBase> heap = camMemory->mHeap;
         if (bufferIndex >= camMemory->mNumBufs) {
             ALOGE("%s: bufferIndex %d exceeds number of buffers %d",
                     __FUNCTION__, bufferIndex, camMemory->mNumBufs);
             return;
         }
-        sp<IMemory> mem = camMemory->mBuffers[bufferIndex];
-        // TODO: simplify below logic once we verify offset is indeed idx * mBufSize
-        //       and heap == heap2
-        ssize_t offset;
-        size_t size;
-        sp<IMemoryHeap> heap2 = mem->getMemory(&offset, &size);
-        if ((size_t)offset != bufferIndex * camMemory->mBufSize) {
-            ALOGI("%s: unexpected offset %zd (was expecting %zu)",
-                    __FUNCTION__, offset, bufferIndex * camMemory->mBufSize);
-        }
-        if (heap != heap2) {
-            ALOGE("%s: heap mismatch!", __FUNCTION__);
-            return;
-        }
-        void *data = ((uint8_t *)heap->base()) + offset;
+        void *data = ((uint8_t *) camMemory->mHidlHeapMemData) + bufferIndex * camMemory->mBufSize;
         if (handle) {
             VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) data;
             if (md->eType == VideoNativeHandleMetadata::kMetadataBufferTypeNativeHandleSource) {
@@ -827,6 +872,17 @@
     return Void();
 }
 
+Return<void> CameraDevice::releaseRecordingFrameHandleBatch(
+        const hidl_vec<VideoFrameMessage>& msgs) {
+    ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+    Mutex::Autolock _l(mLock);
+    for (auto& msg : msgs) {
+        releaseRecordingFrameLocked(
+                msg.data, msg.bufferIndex, msg.frameData.getNativeHandle());
+    }
+    return Void();
+}
+
 Return<Status> CameraDevice::autoFocus() {
     ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
     Mutex::Autolock _l(mLock);
diff --git a/camera/device/1.0/default/CameraDevice_1_0.h b/camera/device/1.0/default/CameraDevice_1_0.h
index 2568f86..a9f55c2 100644
--- a/camera/device/1.0/default/CameraDevice_1_0.h
+++ b/camera/device/1.0/default/CameraDevice_1_0.h
@@ -20,12 +20,12 @@
 #include <unordered_map>
 #include "utils/Mutex.h"
 #include "utils/SortedVector.h"
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
 #include "CameraModule.h"
 #include "HandleImporter.h"
 
 #include <android/hardware/camera/device/1.0/ICameraDevice.h>
+#include <android/hidl/allocator/1.0/IAllocator.h>
+#include <android/hidl/memory/1.0/IMemory.h>
 #include <hidl/MQDescriptor.h>
 #include <hidl/Status.h>
 
@@ -47,7 +47,9 @@
 using ::android::hardware::camera::device::V1_0::ICameraDeviceCallback;
 using ::android::hardware::camera::device::V1_0::ICameraDevicePreviewCallback;
 using ::android::hardware::camera::device::V1_0::MemoryId;
+using ::android::hidl::allocator::V1_0::IAllocator;
 using ::android::hidl::base::V1_0::IBase;
+using ::android::hidl::memory::V1_0::IMemory;
 using ::android::hardware::hidl_array;
 using ::android::hardware::hidl_memory;
 using ::android::hardware::hidl_string;
@@ -93,6 +95,8 @@
     Return<void> releaseRecordingFrame(uint32_t memId, uint32_t bufferIndex) override;
     Return<void> releaseRecordingFrameHandle(
             uint32_t memId, uint32_t bufferIndex, const hidl_handle& frame) override;
+    Return<void> releaseRecordingFrameHandleBatch(
+            const hidl_vec<VideoFrameMessage>&) override;
     Return<Status> autoFocus() override;
     Return<Status> cancelAutoFocus() override;
     Return<Status> takePicture() override;
@@ -111,17 +115,24 @@
     class CameraHeapMemory : public RefBase {
     public:
         CameraHeapMemory(int fd, size_t buf_size, uint_t num_buffers = 1);
-        explicit CameraHeapMemory(size_t buf_size, uint_t num_buffers = 1);
+        explicit CameraHeapMemory(
+            sp<IAllocator> ashmemAllocator, size_t buf_size, uint_t num_buffers = 1);
         void commonInitialization();
         virtual ~CameraHeapMemory();
 
         size_t mBufSize;
         uint_t mNumBufs;
-        // TODO: b/35887419: use hidl_memory instead and get rid of libbinder
-        sp<MemoryHeapBase> mHeap;
-        sp<MemoryBase>* mBuffers;
+
+        // Shared memory related members
+        hidl_memory      mHidlHeap;
+        native_handle_t* mHidlHandle; // contains one shared memory FD
+        void*            mHidlHeapMemData;
+        sp<IMemory>      mHidlHeapMemory; // munmap happens in ~IMemory()
+
         CameraMemory handle;
     };
+    sp<IAllocator> mAshmemAllocator;
+
 
     // TODO: b/35625849
     // Meta data buffer layout for passing a native_handle to codec
@@ -169,6 +180,16 @@
 
     bool mMetadataMode = false;
 
+    mutable Mutex mBatchLock;
+    // Start of protection scope for mBatchLock
+    uint32_t mBatchSize = 0; // 0 for non-batch mode, set to other value to start batching
+    int32_t mBatchMsgType;   // Maybe only allow DataCallbackMsg::VIDEO_FRAME?
+    std::vector<HandleTimestampMessage> mInflightBatch;
+    // End of protection scope for mBatchLock
+
+    void handleCallbackTimestamp(
+            nsecs_t timestamp, int32_t msg_type,
+            MemoryId memId , unsigned index, native_handle_t* handle);
     void releaseRecordingFrameLocked(uint32_t memId, uint32_t bufferIndex, const native_handle_t*);
 
     // shared memory methods
@@ -178,13 +199,13 @@
     // Device callback forwarding methods
     static void sNotifyCb(int32_t msg_type, int32_t ext1, int32_t ext2, void *user);
     static void sDataCb(int32_t msg_type, const camera_memory_t *data, unsigned int index,
-                          camera_frame_metadata_t *metadata, void *user);
+                        camera_frame_metadata_t *metadata, void *user);
     static void sDataCbTimestamp(nsecs_t timestamp, int32_t msg_type,
                                     const camera_memory_t *data, unsigned index, void *user);
 
     // Preview window callback forwarding methods
     static int sDequeueBuffer(struct preview_stream_ops* w,
-                                buffer_handle_t** buffer, int *stride);
+                              buffer_handle_t** buffer, int *stride);
 
     static int sLockBuffer(struct preview_stream_ops* w, buffer_handle_t* buffer);
 
@@ -195,7 +216,7 @@
     static int sSetBufferCount(struct preview_stream_ops* w, int count);
 
     static int sSetBuffersGeometry(struct preview_stream_ops* w,
-                                     int width, int height, int format);
+                                   int width, int height, int format);
 
     static int sSetCrop(struct preview_stream_ops *w, int left, int top, int right, int bottom);
 
diff --git a/camera/device/1.0/types.hal b/camera/device/1.0/types.hal
index bf632d1..ce5205e 100644
--- a/camera/device/1.0/types.hal
+++ b/camera/device/1.0/types.hal
@@ -254,3 +254,36 @@
  * between the HAL and the framework.
  */
 typedef uint32_t MemoryId;
+
+/*
+ * Struct containing arguments of ICameraDeviceCallback::handleCallbackTimestamp.
+ * Used to send a batch of messages in ICameraDeviceCallback::handleCallbackTimestampBatch.
+ */
+struct HandleTimestampMessage {
+    // The handle of image buffer data.
+    handle frameData;
+
+    // A memory handle to the buffer containing the data
+    MemoryId data;
+
+    // The offset into the memory handle where the buffer starts.
+    uint32_t bufferIndex;
+
+    // The time this buffer was captured by the camera, in nanoseconds
+    int64_t timestamp;
+};
+
+/*
+ * Struct containing arguments of ICameraDevice::releaseRecordingFrameHandle.
+ * Used by camera framework to send a batch of recording frames back to camera HAL.
+ */
+struct VideoFrameMessage {
+    // The handle of image buffer data.
+    handle frameData;
+
+    // A memory handle to the buffer containing the data
+    MemoryId data;
+
+    // The offset into the memory handle where the buffer starts.
+    uint32_t bufferIndex;
+};
diff --git a/camera/device/3.2/ICameraDeviceSession.hal b/camera/device/3.2/ICameraDeviceSession.hal
index e186c8d..731fc76 100644
--- a/camera/device/3.2/ICameraDeviceSession.hal
+++ b/camera/device/3.2/ICameraDeviceSession.hal
@@ -183,6 +183,11 @@
      * client, the HAL must process the requests in order of lowest index to
      * highest index.
      *
+     * The cachesToRemove argument contains a list of buffer caches (see
+     * StreamBuffer document for more information on buffer cache) to be removed
+     * by camera HAL. Camera HAL must remove these cache entries whether or not
+     * this method returns OK.
+     *
      * The actual request processing is asynchronous, with the results of
      * capture being returned by the HAL through the processCaptureResult()
      * call. This call requires the result metadata to be available, but output
@@ -238,7 +243,8 @@
      *     that HAL processed successfully before HAL runs into an error.
      *
      */
-    processCaptureRequest(vec<CaptureRequest> requests)
+    processCaptureRequest(vec<CaptureRequest> requests,
+            vec<BufferCache> cachesToRemove)
             generates (Status status, uint32_t numRequestProcessed);
 
     /**
diff --git a/camera/device/3.2/default/CameraDeviceSession.cpp b/camera/device/3.2/default/CameraDeviceSession.cpp
index fb1d1ff..5b3024b 100644
--- a/camera/device/3.2/default/CameraDeviceSession.cpp
+++ b/camera/device/3.2/default/CameraDeviceSession.cpp
@@ -678,8 +678,32 @@
     mCirculatingBuffers.erase(id);
 }
 
+void CameraDeviceSession::updateBufferCaches(const hidl_vec<BufferCache>& cachesToRemove) {
+    Mutex::Autolock _l(mInflightLock);
+    for (auto& cache : cachesToRemove) {
+        auto cbsIt = mCirculatingBuffers.find(cache.streamId);
+        if (cbsIt == mCirculatingBuffers.end()) {
+            // The stream could have been removed
+            continue;
+        }
+        CirculatingBuffers& cbs = cbsIt->second;
+        auto it = cbs.find(cache.bufferId);
+        if (it != cbs.end()) {
+            sHandleImporter.freeBuffer(it->second);
+            cbs.erase(it);
+        } else {
+            ALOGE("%s: stream %d buffer %" PRIu64 " is not cached",
+                    __FUNCTION__, cache.streamId, cache.bufferId);
+        }
+    }
+}
+
 Return<void> CameraDeviceSession::processCaptureRequest(
-        const hidl_vec<CaptureRequest>& requests, processCaptureRequest_cb _hidl_cb)  {
+        const hidl_vec<CaptureRequest>& requests,
+        const hidl_vec<BufferCache>& cachesToRemove,
+        processCaptureRequest_cb _hidl_cb)  {
+    updateBufferCaches(cachesToRemove);
+
     uint32_t numRequestProcessed = 0;
     Status s = Status::OK;
     for (size_t i = 0; i < requests.size(); i++, numRequestProcessed++) {
diff --git a/camera/device/3.2/default/CameraDeviceSession.h b/camera/device/3.2/default/CameraDeviceSession.h
index 8923c05..781056e 100644
--- a/camera/device/3.2/default/CameraDeviceSession.h
+++ b/camera/device/3.2/default/CameraDeviceSession.h
@@ -85,7 +85,9 @@
     Return<void> configureStreams(
             const StreamConfiguration& requestedConfiguration, configureStreams_cb _hidl_cb) override;
     Return<void> processCaptureRequest(
-            const hidl_vec<CaptureRequest>& requests, processCaptureRequest_cb _hidl_cb) override;
+            const hidl_vec<CaptureRequest>& requests,
+            const hidl_vec<BufferCache>& cachesToRemove,
+            processCaptureRequest_cb _hidl_cb) override;
     Return<Status> flush() override;
     Return<void> close() override;
 
@@ -234,6 +236,8 @@
 
     void cleanupBuffersLocked(int id);
 
+    void updateBufferCaches(const hidl_vec<BufferCache>& cachesToRemove);
+
     Status processOneCaptureRequest(const CaptureRequest& request);
     /**
      * Static callback forwarding methods from HAL to instance
diff --git a/camera/device/3.2/types.hal b/camera/device/3.2/types.hal
index fd75528..5ae7a18 100644
--- a/camera/device/3.2/types.hal
+++ b/camera/device/3.2/types.hal
@@ -958,3 +958,25 @@
     uint32_t partialResult;
 
 };
+
+/**
+ * BufferCache:
+ *
+ * A list of cached bufferIds associated with a certain stream.
+ * Buffers are passed between camera service and camera HAL via bufferId except
+ * the first time a new buffer is being passed to HAL in CaptureRequest. Camera
+ * service and camera HAL therefore need to maintain a cached map of bufferId
+ * and corresponing native handle.
+ *
+ */
+struct BufferCache {
+    /**
+     * The ID of the stream this list is associated with.
+     */
+    int32_t streamId;
+
+    /**
+     * A cached buffer ID associated with streamId.
+     */
+    uint64_t bufferId;
+};
diff --git a/camera/provider/2.4/default/Android.bp b/camera/provider/2.4/default/Android.bp
index 42dec4d..9506827 100644
--- a/camera/provider/2.4/default/Android.bp
+++ b/camera/provider/2.4/default/Android.bp
@@ -15,6 +15,8 @@
         "camera.device@3.2-impl",
         "android.hardware.camera.provider@2.4",
         "android.hardware.camera.common@1.0",
+        "android.hidl.allocator@1.0",
+        "android.hidl.memory@1.0",
         "liblog",
         "libhardware",
         "libcamera_metadata"
diff --git a/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp b/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
index a79c9fa..74e6efe 100644
--- a/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
+++ b/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
@@ -61,6 +61,7 @@
 using ::android::hardware::camera::provider::V2_4::ICameraProvider;
 using ::android::hardware::camera::provider::V2_4::ICameraProviderCallback;
 using ::android::hardware::camera::device::V3_2::ICameraDevice;
+using ::android::hardware::camera::device::V3_2::BufferCache;
 using ::android::hardware::camera::device::V3_2::CaptureRequest;
 using ::android::hardware::camera::device::V3_2::CaptureResult;
 using ::android::hardware::camera::device::V3_2::ICameraDeviceCallback;
@@ -86,6 +87,7 @@
 using ::android::hardware::camera::device::V1_0::CameraFrameMetadata;
 using ::android::hardware::camera::device::V1_0::ICameraDevicePreviewCallback;
 using ::android::hardware::camera::device::V1_0::FrameCallbackFlag;
+using ::android::hardware::camera::device::V1_0::HandleTimestampMessage;
 
 const char kCameraPassthroughServiceName[] = "legacy/0";
 const uint32_t kMaxPreviewWidth = 1920;
@@ -510,6 +512,10 @@
                 const hidl_handle& frameData,uint32_t data,
                 uint32_t bufferIndex, int64_t timestamp) override;
 
+        Return<void> handleCallbackTimestampBatch(DataCallbackMsg msgType,
+                const ::android::hardware::hidl_vec<HandleTimestampMessage>& batch) override;
+
+
      private:
         CameraHidlTest *mParent;               // Parent object
     };
@@ -666,6 +672,23 @@
     return Void();
 }
 
+Return<void> CameraHidlTest::Camera1DeviceCb::handleCallbackTimestampBatch(
+        DataCallbackMsg msgType,
+        const hidl_vec<HandleTimestampMessage>& batch) {
+    std::unique_lock<std::mutex> l(mParent->mLock);
+    for (auto& msg : batch) {
+        mParent->mDataMessageTypeReceived = msgType;
+        mParent->mVideoBufferIndex = msg.bufferIndex;
+        if (mParent->mMemoryPool.count(msg.data) == 0) {
+            ADD_FAILURE() << "memory pool ID " << msg.data << " not found";
+        }
+        mParent->mVideoData = msg.data;
+        mParent->mVideoNativeHandle = msg.frameData;
+        mParent->mResultCondition.notify_one();
+    }
+    return Void();
+}
+
 Return<void> CameraHidlTest::DeviceCb::processCaptureResult(
         const hidl_vec<CaptureResult>& results) {
     if (nullptr == mParent) {
@@ -2481,8 +2504,10 @@
 
             Status status = Status::INTERNAL_ERROR;
             uint32_t numRequestProcessed = 0;
+            hidl_vec<BufferCache> cachesToRemove;
             Return<void> returnStatus = session->processCaptureRequest(
                     {request},
+                    cachesToRemove,
                     [&status, &numRequestProcessed] (auto s, uint32_t n) {
                         status = s;
                         numRequestProcessed = n;
@@ -2513,6 +2538,7 @@
 
             returnStatus = session->processCaptureRequest(
                     {request},
+                    cachesToRemove,
                     [&status, &numRequestProcessed] (auto s, uint32_t n) {
                         status = s;
                         numRequestProcessed = n;
@@ -2579,8 +2605,10 @@
             //Settings were not correctly initialized, we should fail here
             Status status = Status::OK;
             uint32_t numRequestProcessed = 0;
+            hidl_vec<BufferCache> cachesToRemove;
             Return<void> ret = session->processCaptureRequest(
                     {request},
+                    cachesToRemove,
                     [&status, &numRequestProcessed] (auto s, uint32_t n) {
                         status = s;
                         numRequestProcessed = n;
@@ -2632,8 +2660,10 @@
             //Output buffers are missing, we should fail here
             Status status = Status::OK;
             uint32_t numRequestProcessed = 0;
+            hidl_vec<BufferCache> cachesToRemove;
             ret = session->processCaptureRequest(
                     {request},
+                    cachesToRemove,
                     [&status, &numRequestProcessed] (auto s, uint32_t n) {
                         status = s;
                         numRequestProcessed = n;
@@ -2701,8 +2731,10 @@
 
             Status status = Status::INTERNAL_ERROR;
             uint32_t numRequestProcessed = 0;
+            hidl_vec<BufferCache> cachesToRemove;
             ret = session->processCaptureRequest(
                     {request},
+                    cachesToRemove,
                     [&status, &numRequestProcessed] (auto s, uint32_t n) {
                         status = s;
                         numRequestProcessed = n;
diff --git a/configstore/1.0/default/SurfaceFlingerConfigs.cpp b/configstore/1.0/default/SurfaceFlingerConfigs.cpp
index 9469ab4..70bd803 100644
--- a/configstore/1.0/default/SurfaceFlingerConfigs.cpp
+++ b/configstore/1.0/default/SurfaceFlingerConfigs.cpp
@@ -12,7 +12,6 @@
 Return<void> SurfaceFlingerConfigs::vsyncEventPhaseOffsetNs(vsyncEventPhaseOffsetNs_cb _hidl_cb) {
 #ifdef VSYNC_EVENT_PHASE_OFFSET_NS
     _hidl_cb({true, VSYNC_EVENT_PHASE_OFFSET_NS});
-    LOG(INFO) << "vsync event phase offset ns =  " << VSYNC_EVENT_PHASE_OFFSET_NS;
 #else
     _hidl_cb({false, 0});
 #endif
@@ -22,7 +21,6 @@
 Return<void> SurfaceFlingerConfigs::vsyncSfEventPhaseOffsetNs(vsyncEventPhaseOffsetNs_cb _hidl_cb) {
 #ifdef SF_VSYNC_EVENT_PHASE_OFFSET_NS
     _hidl_cb({true, SF_VSYNC_EVENT_PHASE_OFFSET_NS});
-    LOG(INFO) << "sfvsync event phase offset ns =  " << SF_VSYNC_EVENT_PHASE_OFFSET_NS;
 #else
     _hidl_cb({false, 0});
 #endif
@@ -32,7 +30,6 @@
 Return<void> SurfaceFlingerConfigs::useContextPriority(useContextPriority_cb _hidl_cb) {
 #ifdef USE_CONTEXT_PRIORITY
     _hidl_cb({true, USE_CONTEXT_PRIORITY});
-    LOG(INFO) << "SurfaceFlinger useContextPriority=" << USE_CONTEXT_PRIORITY;
 #else
     _hidl_cb({false, false});
 #endif
@@ -42,7 +39,6 @@
 Return<void> SurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers(maxFrameBufferAcquiredBuffers_cb _hidl_cb) {
 #ifdef NUM_FRAMEBUFFER_SURFACE_BUFFERS
     _hidl_cb({true, NUM_FRAMEBUFFER_SURFACE_BUFFERS});
-    LOG(INFO) << "SurfaceFlinger FrameBuffer max acquired buffers : " << NUM_FRAMEBUFFER_SURFACE_BUFFERS;
 #else
     _hidl_cb({false, 0});
 #endif
@@ -55,7 +51,6 @@
     value = true;
 #endif
     _hidl_cb({true, value});
-    LOG(INFO) << "SurfaceFlinger Display: " << (value ? "Wide Color" : "Standard Color");
     return Void();
 }
 
@@ -65,7 +60,6 @@
     value = false;
 #endif
     _hidl_cb({true, value});
-    LOG(INFO) << "SurfaceFlinger hasSyncFramework: " << value;
     return Void();
 }
 
@@ -75,14 +69,12 @@
     value = true;
 #endif
     _hidl_cb({true, value});
-    LOG(INFO) << "SurfaceFlinger Display: " << (value ? "HDR" : "SDR");
     return Void();
 }
 
 Return<void> SurfaceFlingerConfigs::presentTimeOffsetFromVSyncNs(presentTimeOffsetFromVSyncNs_cb _hidl_cb) {
 #ifdef PRESENT_TIME_OFFSET_FROM_VSYNC_NS
       _hidl_cb({true, PRESENT_TIME_OFFSET_FROM_VSYNC_NS});
-      LOG(INFO) << "SurfaceFlinger presentTimeStampOffsetNs =  " << PRESENT_TIME_OFFSET_FROM_VSYNC_NS;
 #else
       _hidl_cb({false, 0});
 #endif
@@ -95,7 +87,6 @@
     value = true;
 #endif
     _hidl_cb({true, value});
-    LOG(INFO) << "SurfaceFlinger forceHwcForRGBtoYUV: " << value;
     return Void();
 }
 
@@ -104,7 +95,6 @@
 #ifdef MAX_VIRTUAL_DISPLAY_DIMENSION
   maxSize = MAX_VIRTUAL_DISPLAY_DIMENSION;
   _hidl_cb({true, maxSize});
-  LOG(INFO) << "SurfaceFlinger MaxVirtualDisplaySize: " << maxSize;
 #else
   _hidl_cb({false, maxSize});
 #endif
@@ -119,7 +109,6 @@
     specified = true;
 #endif
     _hidl_cb({specified, value});
-    LOG(INFO) << "SurfaceFlinger UseVrFlinger: " << (value ? "true" : "false");
     return Void();
 }
 
diff --git a/configstore/1.0/default/android.hardware.configstore@1.0-service.rc b/configstore/1.0/default/android.hardware.configstore@1.0-service.rc
index 8741bdd..563d854 100644
--- a/configstore/1.0/default/android.hardware.configstore@1.0-service.rc
+++ b/configstore/1.0/default/android.hardware.configstore@1.0-service.rc
@@ -1,4 +1,4 @@
 service configstore-hal-1-0 /vendor/bin/hw/android.hardware.configstore@1.0-service
-    class hal
+    class hal animation
     user system
     group system
diff --git a/configstore/utils/Android.bp b/configstore/utils/Android.bp
index aa420d1..2c8aad6 100644
--- a/configstore/utils/Android.bp
+++ b/configstore/utils/Android.bp
@@ -14,14 +14,22 @@
 // limitations under the License.
 //
 
-cc_library_headers {
+cc_library_shared {
     name: "android.hardware.configstore-utils",
     defaults: ["hidl_defaults"],
+
+    srcs: [ "ConfigStoreUtils.cpp" ],
+
     export_include_dirs: ["include"],
+
     shared_libs: [
+        "android.hardware.configstore@1.0",
+        "libbase",
         "libhidlbase"
     ],
     export_shared_lib_headers: [
+        "android.hardware.configstore@1.0",
+        "libbase",
         "libhidlbase"
     ],
 }
diff --git a/configstore/utils/ConfigStoreUtils.cpp b/configstore/utils/ConfigStoreUtils.cpp
new file mode 100644
index 0000000..5a1fb42
--- /dev/null
+++ b/configstore/utils/ConfigStoreUtils.cpp
@@ -0,0 +1,40 @@
+//
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#define LOG_TAG "ConfigStore"
+
+#include <android-base/logging.h>
+#include <configstore/Utils.h>
+
+namespace android {
+namespace hardware {
+namespace details {
+
+bool wouldLogInfo() {
+    return WOULD_LOG(INFO);
+}
+
+void logAlwaysInfo(const std::string& message) {
+    LOG(INFO) << message;
+}
+
+void logAlwaysError(const std::string& message) {
+    LOG(ERROR) << message;
+}
+
+}  // namespace details
+}  // namespace hardware
+}  // namespace android
diff --git a/configstore/utils/include/configstore/Utils.h b/configstore/utils/include/configstore/Utils.h
index 46cc9b0..a54ce85 100644
--- a/configstore/utils/include/configstore/Utils.h
+++ b/configstore/utils/include/configstore/Utils.h
@@ -17,24 +17,31 @@
 #ifndef ANDROID_HARDWARE_CONFIGSTORE_UTILS_H
 #define ANDROID_HARDWARE_CONFIGSTORE_UTILS_H
 
+#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
 #include <hidl/Status.h>
-#include <stdatomic.h>
 
-#pragma push_macro("LOG_TAG")
-#undef LOG_TAG
-#define LOG_TAG "ConfigStoreUtil"
+#include <sstream>
 
 namespace android {
 namespace hardware {
+
+namespace details {
+// Templated classes can use the below method
+// to avoid creating dependencies on liblog.
+bool wouldLogInfo();
+void logAlwaysInfo(const std::string& message);
+void logAlwaysError(const std::string& message);
+}  // namespace details
+
 namespace configstore {
+using namespace android::hardware::configstore::V1_0;
 // arguments V: type for the value (i.e., OptionalXXX)
 //           I: interface class name
 //           func: member function pointer
-using namespace V1_0;
-
 template<typename V, typename I, android::hardware::Return<void> (I::* func)
         (std::function<void(const V&)>)>
 decltype(V::value) get(const decltype(V::value) &defValue) {
+    using namespace android::hardware::details;
     auto getHelper = []()->V {
         V ret;
         sp<I> configs = I::getService();
@@ -47,7 +54,11 @@
                 ret = v;
             });
             if (!status.isOk()) {
-                ALOGE("HIDL call failed. %s", status.description().c_str());
+                std::ostringstream oss;
+                oss << "HIDL call failed for retrieving a config item from "
+                       "configstore : "
+                    << status.description().c_str();
+                logAlwaysError(oss.str());
                 ret.specified = false;
             }
         }
@@ -56,6 +67,24 @@
     };
     static V cachedValue = getHelper();
 
+    if (wouldLogInfo()) {
+        std::string iname = __PRETTY_FUNCTION__;
+        // func name starts with "func = " in __PRETTY_FUNCTION__
+        auto pos = iname.find("func = ");
+        if (pos != std::string::npos) {
+            iname = iname.substr(pos + sizeof("func = "));
+            iname.pop_back();  // remove trailing ']'
+        } else {
+            iname += " (unknown)";
+        }
+
+        std::ostringstream oss;
+        oss << iname << " retrieved: "
+            << (cachedValue.specified ? cachedValue.value : defValue)
+            << (cachedValue.specified ? "" : " (default)");
+        logAlwaysInfo(oss.str());
+    }
+
     return cachedValue.specified ? cachedValue.value : defValue;
 }
 
@@ -99,6 +128,4 @@
 }  // namespace hardware
 }  // namespace android
 
-#pragma pop_macro("LOG_TAG")
-
 #endif  // ANDROID_HARDWARE_CONFIGSTORE_UTILS_H
diff --git a/drm/1.0/vts/functional/Android.bp b/drm/1.0/vts/functional/Android.bp
index 546aa12..36d7d1c 100644
--- a/drm/1.0/vts/functional/Android.bp
+++ b/drm/1.0/vts/functional/Android.bp
@@ -15,7 +15,7 @@
 //
 
 cc_test {
-    name: "drm_hidl_test",
+    name: "VtsHalDrmV1_0TargetTest",
     srcs: [
         "drm_hal_clearkey_test.cpp",
         "drm_hal_vendor_test.cpp",
diff --git a/gnss/1.0/IGnssDebug.hal b/gnss/1.0/IGnssDebug.hal
index 716ba88..4c4cfb8 100644
--- a/gnss/1.0/IGnssDebug.hal
+++ b/gnss/1.0/IGnssDebug.hal
@@ -71,8 +71,8 @@
         /** Represents heading in degrees. */
         float bearingDegrees;
         /**
-         * Estimated horizontal accuracy of position expressed in meters, radial,
-         * 68% confidence.
+         * Estimated horizontal accuracy of position expressed in meters,
+         * radial, 68% confidence.
          */
         double horizontalAccuracyMeters;
         /**
@@ -126,7 +126,11 @@
         /** Defines the constellation type of the given SV. */
         GnssConstellationType constellation;
 
-        /** Defines the ephemeris type of the satellite. */
+        /**
+         * Defines the standard broadcast ephemeris or almanac availability for
+         * the satellite.  To report status of predicted orbit and clock
+         * information, see the serverPrediction fields below.
+         */
         SatelliteEphemerisType ephemerisType;
         /** Defines the ephemeris source of the satellite. */
         SatelliteEphemerisSource ephemerisSource;
@@ -143,7 +147,7 @@
         float ephemerisAgeSeconds;
 
         /**
-         * True if a server has provided a predicted orbit (& clock) for
+         * True if a server has provided a predicted orbit and clock model for
          * this satellite.
          */
         bool serverPredictionIsAvailable;
diff --git a/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc b/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc
index 3e2edda..9a08f66 100644
--- a/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc
+++ b/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc
@@ -1,5 +1,5 @@
 service gralloc-2-0 /vendor/bin/hw/android.hardware.graphics.allocator@2.0-service
-    class hal
+    class hal animation
     user system
     group graphics drmrpc
     onrestart restart surfaceflinger
diff --git a/graphics/composer/2.1/default/android.hardware.graphics.composer@2.1-service.rc b/graphics/composer/2.1/default/android.hardware.graphics.composer@2.1-service.rc
index b6060db..51b0e3b 100644
--- a/graphics/composer/2.1/default/android.hardware.graphics.composer@2.1-service.rc
+++ b/graphics/composer/2.1/default/android.hardware.graphics.composer@2.1-service.rc
@@ -1,5 +1,5 @@
 service hwcomposer-2-1 /vendor/bin/hw/android.hardware.graphics.composer@2.1-service
-    class hal
+    class hal animation
     user system
     group graphics drmrpc
     capabilities SYS_NICE
diff --git a/keymaster/3.0/vts/functional/Android.mk b/keymaster/3.0/vts/functional/Android.mk
index 4265b9f..4098664 100644
--- a/keymaster/3.0/vts/functional/Android.mk
+++ b/keymaster/3.0/vts/functional/Android.mk
@@ -15,7 +15,7 @@
 LOCAL_PATH := $(call my-dir)
 
 include $(CLEAR_VARS)
-LOCAL_MODULE := keymaster_hidl_hal_test
+LOCAL_MODULE := VtsHalKeymasterV3_0TargetTest
 LOCAL_SRC_FILES := \
         authorization_set.cpp \
         attestation_record.cpp \
diff --git a/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp b/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp
index 2382f0b..edb1cd1 100644
--- a/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp
+++ b/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp
@@ -46,6 +46,8 @@
 // non-gtest argument will be used as the service name.
 string service_name = "default";
 
+static bool arm_deleteAllKeys = false;
+
 namespace android {
 namespace hardware {
 
@@ -488,13 +490,20 @@
         return ExportKey(format, key_blob_, client_id, app_data, key_material);
     }
 
-    ErrorCode DeleteKey(HidlBuf* key_blob) {
+    ErrorCode DeleteKey(HidlBuf* key_blob, bool keep_key_blob = false) {
         ErrorCode error = keymaster_->deleteKey(*key_blob);
-        *key_blob = HidlBuf();
+        if (!keep_key_blob) *key_blob = HidlBuf();
         return error;
     }
 
-    ErrorCode DeleteKey() { return DeleteKey(&key_blob_); }
+    ErrorCode DeleteKey(bool keep_key_blob = false) {
+        return DeleteKey(&key_blob_, keep_key_blob);
+    }
+
+    ErrorCode DeleteAllKeys() {
+        ErrorCode error = keymaster_->deleteAllKeys();
+        return error;
+    }
 
     ErrorCode GetCharacteristics(const HidlBuf& key_blob, const HidlBuf& client_id,
                                  const HidlBuf& app_data, KeyCharacteristics* key_characteristics) {
@@ -3893,6 +3902,124 @@
                         &cert_chain));
 }
 
+typedef KeymasterHidlTest KeyDeletionTest;
+
+/**
+ * KeyDeletionTest.DeleteKey
+ *
+ * This test checks that if rollback protection is implemented, DeleteKey invalidates a formerly
+ * valid key blob.
+ */
+TEST_F(KeyDeletionTest, DeleteKey) {
+    ASSERT_EQ(ErrorCode::OK, GenerateKey(AuthorizationSetBuilder()
+                                             .RsaSigningKey(1024, 3)
+                                             .Digest(Digest::NONE)
+                                             .Padding(PaddingMode::NONE)
+                                             .Authorization(TAG_NO_AUTH_REQUIRED)));
+
+    // Delete must work if rollback protection is implemented
+    AuthorizationSet teeEnforced(key_characteristics_.teeEnforced);
+    bool rollback_protected = teeEnforced.Contains(TAG_ROLLBACK_RESISTANT);
+
+    if (rollback_protected) {
+        ASSERT_EQ(ErrorCode::OK, DeleteKey(true /* keep key blob */));
+    } else {
+        auto delete_result = DeleteKey(true /* keep key blob */);
+        ASSERT_TRUE(delete_result == ErrorCode::OK | delete_result == ErrorCode::UNIMPLEMENTED);
+    }
+
+    string message = "12345678901234567890123456789012";
+    AuthorizationSet begin_out_params;
+
+    if (rollback_protected) {
+        EXPECT_EQ(ErrorCode::INVALID_KEY_BLOB,
+                Begin(KeyPurpose::SIGN, key_blob_,
+                        AuthorizationSetBuilder().Digest(Digest::NONE).Padding(PaddingMode::NONE),
+                        &begin_out_params, &op_handle_));
+    } else {
+        EXPECT_EQ(ErrorCode::OK,
+                Begin(KeyPurpose::SIGN, key_blob_,
+                        AuthorizationSetBuilder().Digest(Digest::NONE).Padding(PaddingMode::NONE),
+                        &begin_out_params, &op_handle_));
+    }
+    AbortIfNeeded();
+    key_blob_ = HidlBuf();
+}
+
+/**
+ * KeyDeletionTest.DeleteInvalidKey
+ *
+ * This test checks that the HAL excepts invalid key blobs.
+ */
+TEST_F(KeyDeletionTest, DeleteInvalidKey) {
+    // Generate key just to check if rollback protection is implemented
+    ASSERT_EQ(ErrorCode::OK, GenerateKey(AuthorizationSetBuilder()
+                                             .RsaSigningKey(1024, 3)
+                                             .Digest(Digest::NONE)
+                                             .Padding(PaddingMode::NONE)
+                                             .Authorization(TAG_NO_AUTH_REQUIRED)));
+
+    // Delete must work if rollback protection is implemented
+    AuthorizationSet teeEnforced(key_characteristics_.teeEnforced);
+    bool rollback_protected = teeEnforced.Contains(TAG_ROLLBACK_RESISTANT);
+
+    // Delete the key we don't care about the result at this point.
+    DeleteKey();
+
+    // Now create an invalid key blob and delete it.
+    key_blob_ = HidlBuf("just some garbage data which is not a valid key blob");
+
+    if (rollback_protected) {
+        ASSERT_EQ(ErrorCode::OK, DeleteKey());
+    } else {
+        auto delete_result = DeleteKey();
+        ASSERT_TRUE(delete_result == ErrorCode::OK | delete_result == ErrorCode::UNIMPLEMENTED);
+    }
+}
+
+/**
+ * KeyDeletionTest.DeleteAllKeys
+ *
+ * This test is disarmed by default. To arm it use --arm_deleteAllKeys.
+ *
+ * BEWARE: This test has serious side effects. All user keys will be lost! This includes
+ * FBE/FDE encryption keys, which means that the device will not even boot until after the
+ * device has been wiped manually (e.g., fastboot flashall -w), and new FBE/FDE keys have
+ * been provisioned. Use this test only on dedicated testing devices that have no valuable
+ * credentials stored in Keystore/Keymaster.
+ */
+TEST_F(KeyDeletionTest, DeleteAllKeys) {
+    if (!arm_deleteAllKeys) return;
+    ASSERT_EQ(ErrorCode::OK, GenerateKey(AuthorizationSetBuilder()
+                                             .RsaSigningKey(1024, 3)
+                                             .Digest(Digest::NONE)
+                                             .Padding(PaddingMode::NONE)
+                                             .Authorization(TAG_NO_AUTH_REQUIRED)));
+
+    // Delete must work if rollback protection is implemented
+    AuthorizationSet teeEnforced(key_characteristics_.teeEnforced);
+    bool rollback_protected = teeEnforced.Contains(TAG_ROLLBACK_RESISTANT);
+
+    ASSERT_EQ(ErrorCode::OK, DeleteAllKeys());
+
+    string message = "12345678901234567890123456789012";
+    AuthorizationSet begin_out_params;
+
+    if (rollback_protected) {
+        EXPECT_EQ(ErrorCode::INVALID_KEY_BLOB,
+                Begin(KeyPurpose::SIGN, key_blob_,
+                        AuthorizationSetBuilder().Digest(Digest::NONE).Padding(PaddingMode::NONE),
+                        &begin_out_params, &op_handle_));
+    } else {
+        EXPECT_EQ(ErrorCode::OK,
+                Begin(KeyPurpose::SIGN, key_blob_,
+                        AuthorizationSetBuilder().Digest(Digest::NONE).Padding(PaddingMode::NONE),
+                        &begin_out_params, &op_handle_));
+    }
+    AbortIfNeeded();
+    key_blob_ = HidlBuf();
+}
+
 }  // namespace test
 }  // namespace V3_0
 }  // namespace keymaster
@@ -3901,9 +4028,19 @@
 
 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
-    if (argc == 2) {
-        ALOGI("Running keymaster VTS against service \"%s\"", argv[1]);
-        service_name = argv[1];
+    std::vector<std::string> positional_args;
+    for (int i = 1; i < argc; ++i) {
+        if (argv[i][0] == '-') {
+            if (std::string(argv[i]) == "--arm_deleteAllKeys") {
+                arm_deleteAllKeys = true;
+            }
+        } else {
+            positional_args.push_back(argv[i]);
+        }
+    }
+    if (positional_args.size()) {
+        ALOGI("Running keymaster VTS against service \"%s\"", positional_args[0].c_str());
+        service_name = positional_args[0];
     }
     int status = RUN_ALL_TESTS();
     ALOGI("Test result = %d", status);
diff --git a/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
index aa3bc9c..cf9f66e 100644
--- a/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
+++ b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
@@ -22,10 +22,8 @@
 #include <android/hardware/nfc/1.0/types.h>
 #include <hardware/nfc.h>
 
+#include <VtsHalHidlTargetCallbackBase.h>
 #include <VtsHalHidlTargetTestBase.h>
-#include <chrono>
-#include <condition_variable>
-#include <mutex>
 
 using ::android::hardware::nfc::V1_0::INfc;
 using ::android::hardware::nfc::V1_0::INfcClientCallback;
@@ -55,6 +53,43 @@
 #define VERSION 0x11
 #define TIMEOUT_PERIOD 5
 
+constexpr char kCallbackNameSendEvent[] = "sendEvent";
+constexpr char kCallbackNameSendData[] = "sendData";
+
+class NfcClientCallbackArgs {
+   public:
+    NfcEvent last_event_;
+    NfcStatus last_status_;
+    NfcData last_data_;
+};
+
+/* Callback class for data & Event. */
+class NfcClientCallback
+    : public ::testing::VtsHalHidlTargetCallbackBase<NfcClientCallbackArgs>,
+      public INfcClientCallback {
+   public:
+    virtual ~NfcClientCallback() = default;
+
+    /* sendEvent callback function - Records the Event & Status
+     * and notifies the TEST
+     **/
+    Return<void> sendEvent(NfcEvent event, NfcStatus event_status) override {
+        NfcClientCallbackArgs args;
+        args.last_event_ = event;
+        args.last_status_ = event_status;
+        NotifyFromCallback(kCallbackNameSendEvent, args);
+        return Void();
+    };
+
+    /* sendData callback function. Records the data and notifies the TEST*/
+    Return<void> sendData(const NfcData& data) override {
+        NfcClientCallbackArgs args;
+        args.last_data_ = data;
+        NotifyFromCallback(kCallbackNameSendData, args);
+        return Void();
+    };
+};
+
 // The main test class for NFC HIDL HAL.
 class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase {
  public:
@@ -62,88 +97,28 @@
     nfc_ = ::testing::VtsHalHidlTargetTestBase::getService<INfc>();
     ASSERT_NE(nfc_, nullptr);
 
-    nfc_cb_ = new NfcClientCallback(*this);
+    nfc_cb_ = new NfcClientCallback();
     ASSERT_NE(nfc_cb_, nullptr);
 
-    count = 0;
-    last_event_ = NfcEvent::ERROR;
-    last_status_ = NfcStatus::FAILED;
-
     EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
     // Wait for OPEN_CPLT event
-    EXPECT_EQ(std::cv_status::no_timeout, wait());
-    EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
-    EXPECT_EQ(NfcStatus::OK, last_status_);
+    auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+    EXPECT_TRUE(res.no_timeout);
+    EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+    EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
   }
 
   virtual void TearDown() override {
     EXPECT_EQ(NfcStatus::OK, nfc_->close());
     // Wait for CLOSE_CPLT event
-    EXPECT_EQ(std::cv_status::no_timeout, wait());
-    EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
-    EXPECT_EQ(NfcStatus::OK, last_status_);
+    auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+    EXPECT_TRUE(res.no_timeout);
+    EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
+    EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
   }
 
-  /* Used as a mechanism to inform the test about data/event callback */
-  inline void notify() {
-    std::unique_lock<std::mutex> lock(mtx);
-    count++;
-    cv.notify_one();
-  }
-
-  /* Test code calls this function to wait for data/event callback */
-  inline std::cv_status wait() {
-    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;
-    }
-    count--;
-    return status;
-  }
-
-  /* Callback class for data & Event. */
-  class NfcClientCallback : public INfcClientCallback {
-    NfcHidlTest& parent_;
-
-   public:
-    NfcClientCallback(NfcHidlTest& parent) : parent_(parent){};
-
-    virtual ~NfcClientCallback() = default;
-
-    /* sendEvent callback function - Records the Event & Status
-     * and notifies the TEST
-     **/
-    Return<void> sendEvent(NfcEvent event, NfcStatus event_status) override {
-      parent_.last_event_ = event;
-      parent_.last_status_ = event_status;
-      parent_.notify();
-      return Void();
-    };
-
-    /* sendData callback function. Records the data and notifies the TEST*/
-    Return<void> sendData(const NfcData& data) override {
-      size_t size = parent_.last_data_.size();
-      parent_.last_data_.resize(size + 1);
-      parent_.last_data_[size] = data;
-      parent_.notify();
-      return Void();
-    };
-  };
-
   sp<INfc> nfc_;
-  sp<INfcClientCallback> nfc_cb_;
-  NfcEvent last_event_;
-  NfcStatus last_status_;
-  hidl_vec<NfcData> last_data_;
-
- private:
-  std::mutex mtx;
-  std::condition_variable cv;
-  int count;
+  sp<NfcClientCallback> nfc_cb_;
 };
 
 // A class for test environment setup (kept since this file is a template).
@@ -175,12 +150,12 @@
   NfcData data = cmd;
   EXPECT_EQ(data.size(), nfc_->write(data));
   // Wait for CORE_RESET_RSP
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(1ul, last_data_.size());
-  EXPECT_EQ(6ul, last_data_[0].size());
-  EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
-  EXPECT_GE(VERSION, last_data_[0][4]);
-  EXPECT_EQ(0ul, last_data_[0][5]);
+  auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(6ul, res.args->last_data_.size());
+  EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
+  EXPECT_GE(VERSION, res.args->last_data_[4]);
+  EXPECT_EQ(0ul, res.args->last_data_[5]);
 }
 
 /*
@@ -194,12 +169,12 @@
   NfcData data = cmd;
   EXPECT_EQ(data.size(), nfc_->write(data));
   // Wait for CORE_RESET_RSP
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(1ul, last_data_.size());
-  EXPECT_EQ(6ul, last_data_[0].size());
-  EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
-  EXPECT_GE(VERSION, last_data_[0][4]);
-  EXPECT_EQ(1ul, last_data_[0][5]);
+  auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(6ul, res.args->last_data_.size());
+  EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
+  EXPECT_GE(VERSION, res.args->last_data_[4]);
+  EXPECT_EQ(1ul, res.args->last_data_[5]);
 }
 
 /*
@@ -214,10 +189,10 @@
   NfcData data = cmd;
   EXPECT_EQ(data.size(), nfc_->write(data));
   // Wait for RSP
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(1ul, last_data_.size());
-  EXPECT_EQ(4ul, last_data_[0].size());
-  EXPECT_EQ(SYNTAX_ERROR, last_data_[0][3]);
+  auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(4ul, res.args->last_data_.size());
+  EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]);
 }
 
 /*
@@ -236,29 +211,27 @@
   size_t size = data.size();
 
   for (int i = 0; i < 100; i++) {
-    last_data_.resize(0);
     data.resize(++size);
     data[size - 1] = 0xFF;
     EXPECT_EQ(data.size(), nfc_->write(data));
     // Wait for CORE_INTERFACE_ERROR_NTF
-    EXPECT_EQ(std::cv_status::no_timeout, wait());
-    EXPECT_EQ(1ul, last_data_.size());
-    EXPECT_EQ(5ul, last_data_[0].size());
-    EXPECT_EQ(0x60, last_data_[0][0]);
-    EXPECT_EQ(0x08, last_data_[0][1]);
-    EXPECT_EQ(0x02, last_data_[0][2]);
-    EXPECT_EQ(SYNTAX_ERROR, last_data_[0][3]);
+    auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+    EXPECT_TRUE(res.no_timeout);
+    EXPECT_EQ(5ul, res.args->last_data_.size());
+    EXPECT_EQ(0x60, res.args->last_data_[0]);
+    EXPECT_EQ(0x08, res.args->last_data_[1]);
+    EXPECT_EQ(0x02, res.args->last_data_[2]);
+    EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]);
   }
 
   cmd = CORE_CONN_CREATE_CMD;
   data = cmd;
-  last_data_.resize(0);
   EXPECT_EQ(data.size(), nfc_->write(data));
   // Wait for CORE_CONN_CREATE_RSP
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(1ul, last_data_.size());
-  EXPECT_EQ(7ul, last_data_[0].size());
-  EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
+  auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(7ul, res.args->last_data_.size());
+  EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
 }
 /*
  * Bandwidth:
@@ -273,40 +246,48 @@
   NfcData data = cmd;
   EXPECT_EQ(data.size(), nfc_->write(data));
   // Wait for CORE_CONN_CREATE_RSP
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(1ul, last_data_.size());
-  EXPECT_EQ(7ul, last_data_[0].size());
-  EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
-  uint8_t conn_id = last_data_[0][6];
-  uint32_t max_payload_size = last_data_[0][4];
+  auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(7ul, res.args->last_data_.size());
+  EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
+  uint8_t conn_id = res.args->last_data_[6];
+  uint32_t max_payload_size = res.args->last_data_[4];
 
   for (int loops = 0; loops < NUMBER_LOOPS; loops++) {
-    last_data_.resize(0);
-    data.resize(max_payload_size + LOOP_BACK_HEADER_SIZE);
-    data[0] = conn_id;
-    data[1] = 0x00;
-    data[2] = max_payload_size;
-    for (uint32_t i = 0; i < max_payload_size; i++) {
-      data[i + LOOP_BACK_HEADER_SIZE] = i;
+      res.args->last_data_.resize(0);
+      data.resize(max_payload_size + LOOP_BACK_HEADER_SIZE);
+      data[0] = conn_id;
+      data[1] = 0x00;
+      data[2] = max_payload_size;
+      for (uint32_t i = 0; i < max_payload_size; i++) {
+          data[i + LOOP_BACK_HEADER_SIZE] = i;
     }
     EXPECT_EQ(max_payload_size + LOOP_BACK_HEADER_SIZE, nfc_->write(data));
     // Wait for data and CORE_CONN_CREDITS_NTF
-    EXPECT_EQ(std::cv_status::no_timeout, wait());
-    EXPECT_EQ(std::cv_status::no_timeout, wait());
-    // Check if the same data was recieved back
-    EXPECT_EQ(2ul, last_data_.size());
+    auto res1 = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+    EXPECT_TRUE(res1.no_timeout);
+    auto res2 = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+    EXPECT_TRUE(res2.no_timeout);
+    // Check if the same data was received back
+    EXPECT_TRUE(res1.args);
+    EXPECT_TRUE(res2.args);
 
+    NfcData credits_ntf = res1.args->last_data_;
+    NfcData received_data = res2.args->last_data_;
     /* It is possible that CORE_CONN_CREDITS_NTF is received before data,
      * Find the order and do further checks depending on that */
-    uint8_t data_index = last_data_[0].size() == data.size() ? 0 : 1;
-    EXPECT_EQ(data.size(), last_data_[data_index].size());
+    if (received_data.size() != data.size()) {
+        credits_ntf = res2.args->last_data_;
+        received_data = res1.args->last_data_;
+    }
+    EXPECT_EQ(data.size(), received_data.size());
     for (size_t i = 0; i < data.size(); i++) {
-      EXPECT_EQ(data[i], last_data_[data_index][i]);
+        EXPECT_EQ(data[i], received_data[i]);
     }
 
-    EXPECT_EQ(6ul, last_data_[!data_index].size());
+    EXPECT_EQ(6ul, credits_ntf.size());
     // Check if the credit is refilled to 1
-    EXPECT_EQ(1, last_data_[!data_index][5]);
+    EXPECT_EQ(1, credits_ntf[5]);
   }
 }
 
@@ -319,9 +300,10 @@
 TEST_F(NfcHidlTest, PowerCycle) {
   EXPECT_EQ(NfcStatus::OK, nfc_->powerCycle());
   // Wait for NfcEvent.OPEN_CPLT
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
-  EXPECT_EQ(NfcStatus::OK, last_status_);
+  auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+  EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 }
 
 /*
@@ -332,17 +314,19 @@
 TEST_F(NfcHidlTest, PowerCycleAfterClose) {
   EXPECT_EQ(NfcStatus::OK, nfc_->close());
   // Wait for CLOSE_CPLT event
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
-  EXPECT_EQ(NfcStatus::OK, last_status_);
+  auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
+  EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 
   EXPECT_EQ(NfcStatus::FAILED, nfc_->powerCycle());
 
   EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
   // Wait for OPEN_CPLT event
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
-  EXPECT_EQ(NfcStatus::OK, last_status_);
+  res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+  EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 }
 
 /*
@@ -353,13 +337,16 @@
 TEST_F(NfcHidlTest, CoreInitialized) {
   NfcData data;
   data.resize(1);
-  for (int i = 0; i <= 6; i++)
-  {
-    data[0] = i;
-    EXPECT_EQ(NfcStatus::OK, nfc_->coreInitialized(data));
-    // Wait for NfcEvent.POST_INIT_CPLT
-    EXPECT_EQ(std::cv_status::no_timeout, wait());
-    EXPECT_EQ(NfcEvent::POST_INIT_CPLT, last_event_);
+  // These parameters might lead to device specific proprietary behavior
+  // Using > 10 values should result in predictable and common results for
+  // most devices.
+  for (int i = 10; i <= 16; i++) {
+      data[0] = i;
+      EXPECT_EQ(NfcStatus::OK, nfc_->coreInitialized(data));
+      // Wait for NfcEvent.POST_INIT_CPLT
+      auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+      EXPECT_TRUE(res.no_timeout);
+      EXPECT_EQ(NfcEvent::POST_INIT_CPLT, res.args->last_event_);
   }
 }
 
@@ -380,17 +367,19 @@
 TEST_F(NfcHidlTest, ControlGrantedAfterClose) {
   EXPECT_EQ(NfcStatus::OK, nfc_->close());
   // Wait for CLOSE_CPLT event
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
-  EXPECT_EQ(NfcStatus::OK, last_status_);
+  auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
+  EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 
   EXPECT_EQ(NfcStatus::OK, nfc_->controlGranted());
 
   EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
   // Wait for OPEN_CPLT event
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
-  EXPECT_EQ(NfcStatus::OK, last_status_);
+  res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+  EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 }
 
 /* PreDiscover:
@@ -409,17 +398,19 @@
 TEST_F(NfcHidlTest, PreDiscoverAfterClose) {
   EXPECT_EQ(NfcStatus::OK, nfc_->close());
   // Wait for CLOSE_CPLT event
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
-  EXPECT_EQ(NfcStatus::OK, last_status_);
+  auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
+  EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 
   EXPECT_EQ(NfcStatus::OK, nfc_->prediscover());
 
   EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
   // Wait for OPEN_CPLT event
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
-  EXPECT_EQ(NfcStatus::OK, last_status_);
+  res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+  EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 }
 
 /*
@@ -430,20 +421,21 @@
 TEST_F(NfcHidlTest, CloseAfterClose) {
   EXPECT_EQ(NfcStatus::OK, nfc_->close());
   // Wait for CLOSE_CPLT event
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
-  EXPECT_EQ(NfcStatus::OK, last_status_);
+  auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
+  EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 
   EXPECT_EQ(NfcStatus::FAILED, nfc_->close());
 
   EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
   // Wait for OPEN_CPLT event
-  EXPECT_EQ(std::cv_status::no_timeout, wait());
-  EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
-  EXPECT_EQ(NfcStatus::OK, last_status_);
+  res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+  EXPECT_TRUE(res.no_timeout);
+  EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+  EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 }
 
-
 /*
  * OpenAfterOpen:
  * Calls open() multiple times
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() {}
 };
diff --git a/tests/Android.bp b/tests/Android.bp
index 31dc75e..6f99a36 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -9,6 +9,8 @@
     "foo/1.0",
     "foo/1.0/default",
     "foo/1.0/default/lib",
+    "hash/1.0",
+    "hash/1.0/default",
     "inheritance/1.0",
     "inheritance/1.0/default",
     "libhwbinder/1.0",
diff --git a/tests/hash/1.0/Android.bp b/tests/hash/1.0/Android.bp
new file mode 100644
index 0000000..c217e5c
--- /dev/null
+++ b/tests/hash/1.0/Android.bp
@@ -0,0 +1,59 @@
+// This file is autogenerated by hidl-gen. Do not edit manually.
+
+filegroup {
+    name: "android.hardware.tests.hash@1.0_hal",
+    srcs: [
+        "IHash.hal",
+    ],
+}
+
+genrule {
+    name: "android.hardware.tests.hash@1.0_genc++",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.hash@1.0",
+    srcs: [
+        ":android.hardware.tests.hash@1.0_hal",
+    ],
+    out: [
+        "android/hardware/tests/hash/1.0/HashAll.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hardware.tests.hash@1.0_genc++_headers",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.hash@1.0",
+    srcs: [
+        ":android.hardware.tests.hash@1.0_hal",
+    ],
+    out: [
+        "android/hardware/tests/hash/1.0/IHash.h",
+        "android/hardware/tests/hash/1.0/IHwHash.h",
+        "android/hardware/tests/hash/1.0/BnHwHash.h",
+        "android/hardware/tests/hash/1.0/BpHwHash.h",
+        "android/hardware/tests/hash/1.0/BsHash.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hardware.tests.hash@1.0",
+    generated_sources: ["android.hardware.tests.hash@1.0_genc++"],
+    generated_headers: ["android.hardware.tests.hash@1.0_genc++_headers"],
+    export_generated_headers: ["android.hardware.tests.hash@1.0_genc++_headers"],
+    shared_libs: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+        "libcutils",
+        "android.hidl.base@1.0",
+    ],
+    export_shared_lib_headers: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+        "android.hidl.base@1.0",
+    ],
+}
diff --git a/tests/hash/1.0/Android.mk b/tests/hash/1.0/Android.mk
new file mode 100644
index 0000000..15428b4
--- /dev/null
+++ b/tests/hash/1.0/Android.mk
@@ -0,0 +1,76 @@
+# This file is autogenerated by hidl-gen. Do not edit manually.
+
+LOCAL_PATH := $(call my-dir)
+
+################################################################################
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.tests.hash@1.0-java
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+
+intermediates := $(call local-generated-sources-dir, COMMON)
+
+HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
+
+LOCAL_JAVA_LIBRARIES := \
+    android.hidl.base@1.0-java \
+
+
+#
+# Build IHash.hal
+#
+GEN := $(intermediates)/android/hardware/tests/hash/V1_0/IHash.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IHash.hal
+$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
+$(GEN): PRIVATE_CUSTOM_TOOL = \
+        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
+        -Ljava \
+        -randroid.hardware:hardware/interfaces \
+        -randroid.hidl:system/libhidl/transport \
+        android.hardware.tests.hash@1.0::IHash
+
+$(GEN): $(LOCAL_PATH)/IHash.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+include $(BUILD_JAVA_LIBRARY)
+
+
+################################################################################
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.tests.hash@1.0-java-static
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+
+intermediates := $(call local-generated-sources-dir, COMMON)
+
+HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
+
+LOCAL_STATIC_JAVA_LIBRARIES := \
+    android.hidl.base@1.0-java-static \
+
+
+#
+# Build IHash.hal
+#
+GEN := $(intermediates)/android/hardware/tests/hash/V1_0/IHash.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IHash.hal
+$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
+$(GEN): PRIVATE_CUSTOM_TOOL = \
+        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
+        -Ljava \
+        -randroid.hardware:hardware/interfaces \
+        -randroid.hidl:system/libhidl/transport \
+        android.hardware.tests.hash@1.0::IHash
+
+$(GEN): $(LOCAL_PATH)/IHash.hal
+	$(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+include $(BUILD_STATIC_JAVA_LIBRARY)
+
+
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/tests/hash/1.0/IHash.hal b/tests/hash/1.0/IHash.hal
new file mode 100644
index 0000000..ba48384
--- /dev/null
+++ b/tests/hash/1.0/IHash.hal
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.tests.hash@1.0;
+
+/**
+ * Test interface for hashing HAL files.
+ * This file is FREEZED to ensure its hash doesn't change.
+ */
+interface IHash {
+    /**
+     * Dummy.
+     */
+    dummy();
+    /**
+     * Dummy.
+     */
+    functions();
+};
diff --git a/tests/hash/1.0/default/Android.bp b/tests/hash/1.0/default/Android.bp
new file mode 100644
index 0000000..e798a66
--- /dev/null
+++ b/tests/hash/1.0/default/Android.bp
@@ -0,0 +1,15 @@
+cc_library_shared {
+    name: "android.hardware.tests.hash@1.0-impl",
+    relative_install_path: "hw",
+    proprietary: true,
+    srcs: [
+        "Hash.cpp",
+    ],
+    shared_libs: [
+        "libhidlbase",
+        "libhidltransport",
+        "libutils",
+        "android.hardware.tests.hash@1.0",
+        "android.hidl.base@1.0",
+    ],
+}
diff --git a/tests/hash/1.0/default/Hash.cpp b/tests/hash/1.0/default/Hash.cpp
new file mode 100644
index 0000000..caed721
--- /dev/null
+++ b/tests/hash/1.0/default/Hash.cpp
@@ -0,0 +1,30 @@
+#include "Hash.h"
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace hash {
+namespace V1_0 {
+namespace implementation {
+
+// Methods from ::android::hardware::tests::hash::V1_0::IHash follow.
+Return<void> Hash::dummy() {
+    return Void();
+}
+
+Return<void> Hash::functions() {
+    return Void();
+}
+
+// Methods from ::android::hidl::base::V1_0::IBase follow.
+
+IHash* HIDL_FETCH_IHash(const char* /* name */) {
+    return new Hash();
+}
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace hash
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
diff --git a/tests/hash/1.0/default/Hash.h b/tests/hash/1.0/default/Hash.h
new file mode 100644
index 0000000..dd1678f
--- /dev/null
+++ b/tests/hash/1.0/default/Hash.h
@@ -0,0 +1,43 @@
+#ifndef ANDROID_HARDWARE_TESTS_HASH_V1_0_HASH_H
+#define ANDROID_HARDWARE_TESTS_HASH_V1_0_HASH_H
+
+#include <android/hardware/tests/hash/1.0/IHash.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace hash {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::tests::hash::V1_0::IHash;
+using ::android::hidl::base::V1_0::DebugInfo;
+using ::android::hidl::base::V1_0::IBase;
+using ::android::hardware::hidl_array;
+using ::android::hardware::hidl_memory;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::sp;
+
+struct Hash : public IHash {
+    // Methods from ::android::hardware::tests::hash::V1_0::IHash follow.
+    Return<void> dummy() override;
+    Return<void> functions() override;
+
+    // Methods from ::android::hidl::base::V1_0::IBase follow.
+};
+
+extern "C" IHash* HIDL_FETCH_IHash(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace hash
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
+
+#endif  // ANDROID_HARDWARE_TESTS_HASH_V1_0_HASH_H
diff --git a/wifi/1.0/default/hidl_callback_util.h b/wifi/1.0/default/hidl_callback_util.h
index 7136279..b7100c8 100644
--- a/wifi/1.0/default/hidl_callback_util.h
+++ b/wifi/1.0/default/hidl_callback_util.h
@@ -82,7 +82,7 @@
     return true;
   }
 
-  const std::set<android::sp<CallbackType>> getCallbacks() { return cb_set_; }
+  const std::set<android::sp<CallbackType>>& getCallbacks() { return cb_set_; }
 
   // Death notification for callbacks.
   void onObjectDeath(uint64_t cookie) {
diff --git a/wifi/1.0/default/hidl_struct_util.cpp b/wifi/1.0/default/hidl_struct_util.cpp
index c005213..83b2e53 100644
--- a/wifi/1.0/default/hidl_struct_util.cpp
+++ b/wifi/1.0/default/hidl_struct_util.cpp
@@ -417,17 +417,25 @@
     const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
     uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
     if (next_ie + curr_ie_len > ies_end) {
-      return false;
+      LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void *)next_ie
+                 << ", Curr IE len: " << curr_ie_len << ", IEs End: " << (void *)ies_end;
+      break;
     }
     WifiInformationElement hidl_ie;
     if (!convertLegacyIeToHidl(legacy_ie, &hidl_ie)) {
-      return false;
+      LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id
+                 << ", len: " << legacy_ie.len;
+      break;
     }
     hidl_ies->push_back(std::move(hidl_ie));
     next_ie += curr_ie_len;
   }
-  // Ensure that the blob has been fully consumed.
-  return (next_ie == ies_end);
+  // Check if the blob has been fully consumed.
+  if (next_ie != ies_end) {
+    LOG(ERROR) << "Failed to fully parse IE blob. Next IE: " << (void *)next_ie
+               << ", IEs End: " << (void *)ies_end;
+  }
+  return true;
 }
 
 bool convertLegacyGscanResultToHidl(
@@ -774,10 +782,104 @@
   CHECK(false);
 }
 
+legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
+  switch (type) {
+    case NanMatchAlg::MATCH_ONCE:
+      return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
+    case NanMatchAlg::MATCH_CONTINUOUS:
+      return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
+    case NanMatchAlg::MATCH_NEVER:
+      return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
+  }
+  CHECK(false);
+}
+
+legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(NanPublishType type) {
+  switch (type) {
+    case NanPublishType::UNSOLICITED:
+      return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
+    case NanPublishType::SOLICITED:
+      return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
+    case NanPublishType::UNSOLICITED_SOLICITED:
+      return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
+  }
+  CHECK(false);
+}
+
+legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
+  switch (type) {
+    case NanTxType::BROADCAST:
+      return legacy_hal::NAN_TX_TYPE_BROADCAST;
+    case NanTxType::UNICAST:
+      return legacy_hal::NAN_TX_TYPE_UNICAST;
+  }
+  CHECK(false);
+}
+
+legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(NanSubscribeType type) {
+  switch (type) {
+    case NanSubscribeType::PASSIVE:
+      return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
+    case NanSubscribeType::ACTIVE:
+      return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
+  }
+  CHECK(false);
+}
+
+legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
+  switch (type) {
+    case NanSrfType::BLOOM_FILTER:
+      return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
+    case NanSrfType::PARTIAL_MAC_ADDR:
+      return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
+  }
+  CHECK(false);
+}
+
+legacy_hal::NanDataPathChannelCfg convertHidlNanDataPathChannelCfgToLegacy(
+    NanDataPathChannelCfg type) {
+  switch (type) {
+    case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
+      return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
+    case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
+      return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
+    case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
+      return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
+  }
+  CHECK(false);
+}
+
 NanStatusType convertLegacyNanStatusTypeToHidl(
     legacy_hal::NanStatusType type) {
-  // values are identical - may need to do a mapping if they diverge in the future
-  return (NanStatusType) type;
+  switch (type) {
+    case legacy_hal::NAN_STATUS_SUCCESS:
+      return NanStatusType::SUCCESS;
+    case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
+      return NanStatusType::INTERNAL_FAILURE;
+    case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
+      return NanStatusType::PROTOCOL_FAILURE;
+    case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
+      return NanStatusType::INVALID_SESSION_ID;
+    case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
+      return NanStatusType::NO_RESOURCES_AVAILABLE;
+    case legacy_hal::NAN_STATUS_INVALID_PARAM:
+      return NanStatusType::INVALID_ARGS;
+    case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
+      return NanStatusType::INVALID_PEER_ID;
+    case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
+      return NanStatusType::INVALID_NDP_ID;
+    case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
+      return NanStatusType::NAN_NOT_ALLOWED;
+    case legacy_hal::NAN_STATUS_NO_OTA_ACK:
+      return NanStatusType::NO_OTA_ACK;
+    case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
+      return NanStatusType::ALREADY_ENABLED;
+    case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
+      return NanStatusType::FOLLOWUP_TX_QUEUE_FULL;
+    case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
+      return NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
+  }
+  CHECK(false);
 }
 
 bool convertHidlNanEnableRequestToLegacy(
@@ -931,7 +1033,7 @@
   memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(),
         legacy_request->service_name_len);
   legacy_request->publish_match_indicator =
-        (legacy_hal::NanMatchAlg) hidl_request.baseConfigs.discoveryMatchIndicator;
+        convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator);
   legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
   if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
     LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_specific_info_len too large";
@@ -1018,8 +1120,8 @@
   legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired ?
         legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
   legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
-  legacy_request->publish_type = (legacy_hal::NanPublishType) hidl_request.publishType;
-  legacy_request->tx_type = (legacy_hal::NanTxType) hidl_request.txType;
+  legacy_request->publish_type = convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
+  legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
   legacy_request->service_responder_policy = hidl_request.autoAcceptDataPathRequests ?
         legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
 
@@ -1047,7 +1149,7 @@
   memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(),
         legacy_request->service_name_len);
   legacy_request->subscribe_match_indicator =
-        (legacy_hal::NanMatchAlg) hidl_request.baseConfigs.discoveryMatchIndicator;
+        convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator);
   legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
   if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
     LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: service_specific_info_len too large";
@@ -1134,8 +1236,8 @@
   legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired ?
         legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
   legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
-  legacy_request->subscribe_type = (legacy_hal::NanSubscribeType) hidl_request.subscribeType;
-  legacy_request->serviceResponseFilter = (legacy_hal::NanSRFType) hidl_request.srfType;
+  legacy_request->subscribe_type = convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
+  legacy_request->serviceResponseFilter = convertHidlNanSrfTypeToLegacy(hidl_request.srfType);
   legacy_request->serviceResponseInclude = hidl_request.srfRespondIfInAddressSet ?
         legacy_hal::NAN_SRF_INCLUDE_RESPOND : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
   legacy_request->useServiceResponseFilter = hidl_request.shouldUseSrf ?
@@ -1295,7 +1397,7 @@
   legacy_request->requestor_instance_id = hidl_request.peerId;
   memcpy(legacy_request->peer_disc_mac_addr, hidl_request.peerDiscMacAddr.data(), 6);
   legacy_request->channel_request_type =
-        (legacy_hal::NanDataPathChannelCfg) hidl_request.channelRequestType;
+        convertHidlNanDataPathChannelCfgToLegacy(hidl_request.channelRequestType);
   legacy_request->channel = hidl_request.channel;
   strcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str());
   legacy_request->ndp_cfg.security_cfg = (hidl_request.securityConfig.securityType