Merge "add components necessary for bootanim to animation class" into oc-dev
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/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/ICameraDevicePreviewCallback.hal b/camera/device/1.0/ICameraDevicePreviewCallback.hal
index 4c9b517..e772301 100644
--- a/camera/device/1.0/ICameraDevicePreviewCallback.hal
+++ b/camera/device/1.0/ICameraDevicePreviewCallback.hal
@@ -17,7 +17,6 @@
package android.hardware.camera.device@1.0;
import android.hardware.camera.common@1.0::types;
-import android.hardware.graphics.allocator@2.0::types;
import android.hardware.graphics.common@1.0::types;
/**
@@ -89,7 +88,7 @@
*
* @return Status The status code for this operation.
*/
- setUsage(ProducerUsage usage) generates (Status status);
+ setUsage(ProducerUsageFlags usage) generates (Status status);
/**
* Set the expected buffering mode for the preview output.
diff --git a/camera/device/1.0/default/Android.bp b/camera/device/1.0/default/Android.bp
index 5688fc1..a2fd0b0 100644
--- a/camera/device/1.0/default/Android.bp
+++ b/camera/device/1.0/default/Android.bp
@@ -22,8 +22,8 @@
"libbinder",
],
static_libs: [
- "android.hardware.camera.common@1.0-helper"
+ "android.hardware.camera.common@1.0-helper",
+ "libgrallocusage"
],
export_include_dirs: ["."]
}
-
diff --git a/camera/device/1.0/default/CameraDevice.cpp b/camera/device/1.0/default/CameraDevice.cpp
index 819525b..5e3fcf2 100644
--- a/camera/device/1.0/default/CameraDevice.cpp
+++ b/camera/device/1.0/default/CameraDevice.cpp
@@ -20,6 +20,8 @@
#include <hardware/gralloc1.h>
#include <utils/Trace.h>
+#include <grallocusage/GrallocUsageConversion.h>
+
#include "CameraDevice_1_0.h"
namespace android {
@@ -29,7 +31,6 @@
namespace V1_0 {
namespace implementation {
-using ::android::hardware::graphics::allocator::V2_0::ProducerUsage;
using ::android::hardware::graphics::common::V1_0::PixelFormat;
HandleImporter& CameraDevice::sHandleImporter = HandleImporter::getInstance();
@@ -252,7 +253,10 @@
}
object->cleanUpCirculatingBuffers();
- return getStatusT(object->mPreviewCallback->setUsage((ProducerUsage) usage));
+ ProducerUsageFlags producerUsage;
+ uint64_t consumerUsage;
+ ::android_convertGralloc0To1Usage(usage, &producerUsage, &consumerUsage);
+ return getStatusT(object->mPreviewCallback->setUsage(producerUsage));
}
int CameraDevice::sSetSwapInterval(struct preview_stream_ops *w, int interval) {
@@ -420,6 +424,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__);
@@ -450,8 +487,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);
}
}
}
@@ -827,6 +863,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..ad5f582 100644
--- a/camera/device/1.0/default/CameraDevice_1_0.h
+++ b/camera/device/1.0/default/CameraDevice_1_0.h
@@ -93,6 +93,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;
@@ -169,6 +171,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 +190,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 +207,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..0b3445f 100644
--- a/camera/device/1.0/types.hal
+++ b/camera/device/1.0/types.hal
@@ -16,6 +16,10 @@
package android.hardware.camera.device@1.0;
+import android.hardware.graphics.allocator@2.0::types;
+
+typedef bitfield<ProducerUsage> ProducerUsageFlags;
+
enum CameraFacing : uint32_t {
/** The facing of the camera is opposite to that of the screen. */
BACK = 0,
@@ -254,3 +258,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/default/Android.bp b/camera/device/3.2/default/Android.bp
index e0dc5ff..5a81d41 100644
--- a/camera/device/3.2/default/Android.bp
+++ b/camera/device/3.2/default/Android.bp
@@ -17,7 +17,8 @@
"libcamera_metadata"
],
static_libs: [
- "android.hardware.camera.common@1.0-helper"
+ "android.hardware.camera.common@1.0-helper",
+ "libgrallocusage"
],
export_include_dirs: ["."]
}
diff --git a/camera/device/3.2/default/CameraDeviceSession.cpp b/camera/device/3.2/default/CameraDeviceSession.cpp
index fb1d1ff..2887a75 100644
--- a/camera/device/3.2/default/CameraDeviceSession.cpp
+++ b/camera/device/3.2/default/CameraDeviceSession.cpp
@@ -611,7 +611,7 @@
return Void();
}
mStreamMap[id].rotation = (int) requestedConfiguration.streams[i].rotation;
- mStreamMap[id].usage = (uint32_t) requestedConfiguration.streams[i].usage;
+ mStreamMap[id].usage = convertFromHidlUsage(requestedConfiguration.streams[i].usage);
}
streams[i] = &mStreamMap[id];
}
diff --git a/camera/device/3.2/default/convert.cpp b/camera/device/3.2/default/convert.cpp
index 35676df..c99d903 100644
--- a/camera/device/3.2/default/convert.cpp
+++ b/camera/device/3.2/default/convert.cpp
@@ -15,8 +15,12 @@
*/
#define LOG_TAG "android.hardware.camera.device@3.2-convert-impl"
+#include <inttypes.h>
+
#include <android/log.h>
+#include <grallocusage/GrallocUsageConversion.h>
+
#include "include/convert.h"
namespace android {
@@ -28,6 +32,7 @@
using ::android::hardware::graphics::common::V1_0::Dataspace;
using ::android::hardware::graphics::common::V1_0::PixelFormat;
+using ::android::hardware::graphics::allocator::V2_0::ConsumerUsage;
using ::android::hardware::camera::device::V3_2::ConsumerUsageFlags;
using ::android::hardware::camera::device::V3_2::ProducerUsageFlags;
@@ -66,23 +71,37 @@
dst->format = (int) src.format;
dst->data_space = (android_dataspace_t) src.dataSpace;
dst->rotation = (int) src.rotation;
- dst->usage = (uint32_t) src.usage;
+ dst->usage = convertFromHidlUsage(src.usage);
// Fields to be filled by HAL (max_buffers, priv) are initialized to 0
dst->max_buffers = 0;
dst->priv = 0;
return;
}
+uint32_t convertFromHidlUsage(ConsumerUsageFlags usage) {
+ uint32_t dstUsage = 0;
+ dstUsage = ::android_convertGralloc1To0Usage(/*producerUsage*/ 0, usage);
+ // Compatibility workaround - add HW_CAMERA_ZSL when ConsumerUsage.CAMERA is set, to
+ // match pre-HIDL expected usage flags
+ if ( (usage & ConsumerUsage::CAMERA) == static_cast<uint64_t>(ConsumerUsage::CAMERA)) {
+ dstUsage |= GRALLOC_USAGE_HW_CAMERA_ZSL;
+ }
+ return dstUsage;
+}
+
void convertToHidl(const Camera3Stream* src, HalStream* dst) {
dst->id = src->mId;
dst->overrideFormat = (PixelFormat) src->format;
dst->maxBuffers = src->max_buffers;
+ ConsumerUsageFlags consumerUsage;
+ ProducerUsageFlags producerUsage;
+ ::android_convertGralloc0To1Usage(src->usage, &producerUsage, &consumerUsage);
if (src->stream_type == CAMERA3_STREAM_OUTPUT) {
dst->consumerUsage = (ConsumerUsageFlags) 0;
- dst->producerUsage = (ProducerUsageFlags) src->usage;
+ dst->producerUsage = producerUsage;
} else if (src->stream_type == CAMERA3_STREAM_INPUT) {
dst->producerUsage = (ProducerUsageFlags) 0;
- dst->consumerUsage = (ConsumerUsageFlags) src->usage;
+ dst->consumerUsage = consumerUsage;
} else {
//Should not reach here per current HIDL spec, but we might end up adding
// bi-directional stream to HIDL.
diff --git a/camera/device/3.2/default/include/convert.h b/camera/device/3.2/default/include/convert.h
index 96891f0..7c8e02f 100644
--- a/camera/device/3.2/default/include/convert.h
+++ b/camera/device/3.2/default/include/convert.h
@@ -45,6 +45,8 @@
void convertFromHidl(const Stream &src, Camera3Stream* dst);
void convertToHidl(const Camera3Stream* src, HalStream* dst);
+uint32_t convertFromHidlUsage(ConsumerUsageFlags usage);
+
void convertFromHidl(
buffer_handle_t*, BufferStatus, camera3_stream_t*, int acquireFence, // inputs
camera3_stream_buffer_t* dst);
diff --git a/camera/provider/2.4/vts/functional/Android.bp b/camera/provider/2.4/vts/functional/Android.bp
index a0be5cb..02c42c9 100644
--- a/camera/provider/2.4/vts/functional/Android.bp
+++ b/camera/provider/2.4/vts/functional/Android.bp
@@ -33,7 +33,10 @@
"libgui",
"libui"
],
- static_libs: ["VtsHalHidlTargetTestBase"],
+ static_libs: [
+ "VtsHalHidlTargetTestBase",
+ "libgrallocusage"
+ ],
cflags: [
"-O0",
"-g",
diff --git a/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp b/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
index a79c9fa..af7e3bf 100644
--- a/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
+++ b/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
@@ -21,6 +21,7 @@
#include "CameraParameters.h"
#include <system/camera.h>
#include <android/log.h>
+#include <grallocusage/GrallocUsageConversion.h>
#include <ui/GraphicBuffer.h>
#include <VtsHalHidlTargetTestBase.h>
#include <gui/BufferQueue.h>
@@ -53,6 +54,7 @@
using ::android::Surface;
using ::android::CameraParameters;
using ::android::hardware::graphics::common::V1_0::PixelFormat;
+using ::android::hardware::graphics::allocator::V2_0::ConsumerUsage;
using ::android::hardware::graphics::allocator::V2_0::ProducerUsage;
using ::android::hardware::camera::common::V1_0::Status;
using ::android::hardware::camera::common::V1_0::CameraDeviceStatus;
@@ -60,6 +62,8 @@
using ::android::hardware::camera::common::V1_0::TorchModeStatus;
using ::android::hardware::camera::provider::V2_4::ICameraProvider;
using ::android::hardware::camera::provider::V2_4::ICameraProviderCallback;
+using ::android::hardware::camera::device::V3_2::ProducerUsageFlags;
+using ::android::hardware::camera::device::V3_2::ConsumerUsageFlags;
using ::android::hardware::camera::device::V3_2::ICameraDevice;
using ::android::hardware::camera::device::V3_2::CaptureRequest;
using ::android::hardware::camera::device::V3_2::CaptureResult;
@@ -79,6 +83,7 @@
using ::android::hardware::camera::device::V3_2::MsgType;
using ::android::hardware::camera::device::V3_2::ErrorMsg;
using ::android::hardware::camera::device::V3_2::ErrorCode;
+using ::android::hardware::camera::device::V1_0::ProducerUsageFlags;
using ::android::hardware::camera::device::V1_0::CameraFacing;
using ::android::hardware::camera::device::V1_0::NotifyCallbackMsg;
using ::android::hardware::camera::device::V1_0::CommandType;
@@ -86,6 +91,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;
@@ -231,7 +237,7 @@
Return<Status> setCrop(int32_t left, int32_t top,
int32_t right, int32_t bottom) override;
- Return<Status> setUsage(ProducerUsage usage) override;
+ Return<Status> setUsage(ProducerUsageFlags usage) override;
Return<Status> setSwapInterval(int32_t interval) override;
@@ -406,10 +412,11 @@
return mapToStatus(rc);
}
-Return<Status> PreviewWindowCb::setUsage(ProducerUsage usage) {
- auto rc = native_window_set_usage(mAnw.get(), static_cast<int>(usage));
+Return<Status> PreviewWindowCb::setUsage(ProducerUsageFlags usage) {
+ int dstUsage = ::android_convertGralloc1To0Usage(usage, /*consumerUsage*/ 0);
+ auto rc = native_window_set_usage(mAnw.get(), dstUsage);
if (rc == ::android::OK) {
- mPreviewUsage = static_cast<int>(usage);
+ mPreviewUsage = dstUsage;
}
return mapToStatus(rc);
}
@@ -510,6 +517,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 +677,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) {
@@ -2176,7 +2204,7 @@
static_cast<uint32_t> (input.width),
static_cast<uint32_t> (input.height),
static_cast<PixelFormat> (input.format),
- GRALLOC_USAGE_HW_CAMERA_ZSL, 0,
+ static_cast<ConsumerUsageFlags>(ConsumerUsage::CAMERA), 0,
StreamRotation::ROTATION_0};
Stream inputStream = {streamId++, StreamType::INPUT,
static_cast<uint32_t> (input.width),
@@ -2408,7 +2436,7 @@
static_cast<uint32_t> (blobIter.width),
static_cast<uint32_t> (blobIter.height),
static_cast<PixelFormat> (blobIter.format),
- GRALLOC_USAGE_HW_VIDEO_ENCODER, 0,
+ static_cast<ConsumerUsageFlags>(ConsumerUsage::VIDEO_ENCODER), 0,
StreamRotation::ROTATION_0};
::android::hardware::hidl_vec<Stream> streams = {
videoStream, blobStream};
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/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
index aa3bc9c..9da58e2 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,17 @@
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_);
+ NfcEvent last_event_;
+ for (int i = 0; i <= 6; i++) {
+ data[0] = i;
+ EXPECT_EQ(NfcStatus::OK, nfc_->coreInitialized(data));
+ // Wait for NfcEvent.POST_INIT_CPLT
+ auto res = nfc_cb_->WaitForCallbackAny();
+ if (res.name.compare(kCallbackNameSendEvent) == 0) {
+ last_event_ = res.args->last_event_;
+ }
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::POST_INIT_CPLT, last_event_);
}
}
@@ -380,17 +368,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 +399,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 +422,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/wifi/supplicant/1.0/vts/Android.mk b/wifi/supplicant/1.0/vts/Android.mk
new file mode 100644
index 0000000..6361f9b
--- /dev/null
+++ b/wifi/supplicant/1.0/vts/Android.mk
@@ -0,0 +1,2 @@
+LOCAL_PATH := $(call my-dir)
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp
index 1fcfc8c..df4bfa9 100644
--- a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp
+++ b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp
@@ -136,14 +136,14 @@
};
void stopWifiFramework() {
- ASSERT_EQ(std::system("svc wifi disable"), 0);
+ ASSERT_EQ(std::system("stop"), 0);
// TODO: Use some other mechanism to wait for the framework to
// finish disabling.
sleep(5);
}
void startWifiFramework() {
- ASSERT_EQ(std::system("svc wifi enable"), 0);
+ ASSERT_EQ(std::system("start"), 0);
// These tests don't care whether the framework
// finished enabling or not.
}
diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp
index c2a58b6..5abf4e0 100644
--- a/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp
+++ b/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp
@@ -104,11 +104,13 @@
}
Return<void> onDisconnected(const hidl_array<uint8_t, 6>& /* bssid */,
bool /* locallyGenerated */,
- uint32_t /* reasonCode */) override {
+ ISupplicantStaIfaceCallback::ReasonCode
+ /* reasonCode */) override {
return Void();
}
Return<void> onAssociationRejected(
- const hidl_array<uint8_t, 6>& /* bssid */, uint32_t /* statusCode */,
+ const hidl_array<uint8_t, 6>& /* bssid */,
+ ISupplicantStaIfaceCallback::StatusCode /* statusCode */,
bool /*timedOut */) override {
return Void();
}
@@ -116,6 +118,11 @@
const hidl_array<uint8_t, 6>& /* bssid */) override {
return Void();
}
+ Return<void> onBssidChanged(
+ ISupplicantStaIfaceCallback::BssidChangeReason /* reason */,
+ const hidl_array<uint8_t, 6>& /* bssid */) override {
+ return Void();
+ }
Return<void> onEapFailure() override { return Void(); }
Return<void> onWpsEventSuccess() override { return Void(); }
Return<void> onWpsEventFail(