Merge "sensorservice: Add a VTS test that stresses EventQueue creation" into main

2 files changed, 78 insertions, 0 deletions

diff --git a/sensorservice/1.0/vts/functional/VtsHalSensorManagerV1_0TargetTest.cpp b/sensorservice/1.0/vts/functional/VtsHalSensorManagerV1_0TargetTest.cpp
index cd91647..7f01d02 100644
--- a/sensorservice/1.0/vts/functional/VtsHalSensorManagerV1_0TargetTest.cpp
+++ b/sensorservice/1.0/vts/functional/VtsHalSensorManagerV1_0TargetTest.cpp
@@ -35,6 +35,8 @@
 #include <sensors/convert.h>
 
 using ::android::sp;
+using ::android::frameworks::sensorservice::V1_0::IEventQueue;
+using ::android::frameworks::sensorservice::V1_0::IEventQueueCallback;
 using ::android::frameworks::sensorservice::V1_0::ISensorManager;
 using ::android::frameworks::sensorservice::V1_0::Result;
 using ::android::hardware::hidl_memory;
@@ -289,6 +291,42 @@ TEST_P(SensorManagerTest, Accelerometer) {
   }
 }
 
+class QueueCallback : public IEventQueueCallback {
+ public:
+  Return<void> onEvent(const Event &) override {
+    LOG(INFO) << "asdf onEvent callback called";
+    return Return<void>();
+  }
+};
+
+// Make sure the implementation can clean up old queues/loopers
+TEST_P(SensorManagerTest, EventQueueStress) {
+  // sensorservice will create an FD for a looper for each event queue.
+  // Create and destroy an event queue enough times to hit the FD limit if the
+  // FDs are being leaked.
+  struct rlimit rlim;
+  ASSERT_EQ(getrlimit(RLIMIT_NOFILE, &rlim), 0);
+  LOG(INFO) << "rlim is : " << rlim.rlim_cur;
+  for (int i = 0; i <= rlim.rlim_cur; i++) {
+    sp<IEventQueue> queue;
+    sp<IEventQueueCallback> cb = new QueueCallback();
+    ASSERT_OK(manager_->createEventQueue(cb, [&](const sp<IEventQueue> &queue_in, Result result) {
+      EXPECT_OK(result);
+      queue = queue_in;
+    }));
+    EXPECT_NE(queue, nullptr);
+
+    auto sensorList = GetSensorList();
+    ASSERT_RESULT_OK(sensorList);
+    for (const auto &sensor : *sensorList) {
+      if (sensor.flags == 0) continue;
+      ASSERT_OK(queue->enableSensor(sensor.sensorHandle, sensor.minDelay, sensor.minDelay));
+      // Make sure sensor resources can be cleaned up. b/260017505 for cases not calling disable
+      ASSERT_OK(queue->disableSensor(sensor.sensorHandle));
+    }
+  }
+}
+
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SensorManagerTest);
 INSTANTIATE_TEST_SUITE_P(
         PerInstance, SensorManagerTest,
diff --git a/sensorservice/aidl/vts/VtsHalSensorManagerTargetTest.cpp b/sensorservice/aidl/vts/VtsHalSensorManagerTargetTest.cpp
index bf8d242..d71d91e 100644
--- a/sensorservice/aidl/vts/VtsHalSensorManagerTargetTest.cpp
+++ b/sensorservice/aidl/vts/VtsHalSensorManagerTargetTest.cpp
@@ -17,22 +17,27 @@
 #define LOG_TAG "sensor_manager_aidl_hal_test"
 #include <aidl/Gtest.h>
 #include <aidl/Vintf.h>
+#include <aidl/android/frameworks/sensorservice/BnEventQueueCallback.h>
 #include <aidl/android/frameworks/sensorservice/ISensorManager.h>
 #include <aidl/sensors/convert.h>
 #include <android-base/logging.h>
 #include <android-base/result.h>
 #include <android/binder_manager.h>
+#include <android/binder_process.h>
 #include <android/sensor.h>
 #include <binder/IServiceManager.h>
 #include <cutils/ashmem.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <sys/mman.h>
+#include <sys/resource.h>
 
 #include <chrono>
 #include <thread>
 
 using aidl::android::frameworks::sensorservice::IDirectReportChannel;
+using aidl::android::frameworks::sensorservice::IEventQueue;
+using aidl::android::frameworks::sensorservice::IEventQueueCallback;
 using aidl::android::frameworks::sensorservice::ISensorManager;
 using aidl::android::hardware::common::Ashmem;
 using aidl::android::hardware::sensors::Event;
@@ -74,6 +79,8 @@ static ::testing::AssertionResult isIncreasing(I begin, I end, F getField) {
 class SensorManagerTest : public ::testing::TestWithParam<std::string> {
    public:
     virtual void SetUp() override {
+        ABinderProcess_setThreadPoolMaxThreadCount(2);
+        ABinderProcess_startThreadPool();
         manager_ = ISensorManager::fromBinder(
             ndk::SpAIBinder(AServiceManager_waitForService(GetParam().c_str())));
         ASSERT_NE(manager_, nullptr);
@@ -253,6 +260,39 @@ TEST_P(SensorManagerTest, Accelerometer) {
     }
 }
 
+class QueueCallback : public ::aidl::android::frameworks::sensorservice::BnEventQueueCallback {
+    ::ndk::ScopedAStatus onEvent(const ::aidl::android::hardware::sensors::Event&) override {
+        return ::ndk::ScopedAStatus::ok();
+    }
+};
+
+// Make sure the implementation can clean up old queues/loopers
+TEST_P(SensorManagerTest, EventQueueStress) {
+    // sensorservice will create an FD for a looper for each event queue.
+    // Create and destroy an event queue enough times to hit the FD limit if the
+    // FDs are being leaked.
+    struct rlimit rlim;
+    ASSERT_EQ(getrlimit(RLIMIT_NOFILE, &rlim), 0);
+    LOG(INFO) << "rlim is : " << rlim.rlim_cur;
+    for (int i = 0; i <= rlim.rlim_cur; i++) {
+        std::shared_ptr<IEventQueue> queue;
+        std::shared_ptr<IEventQueueCallback> cb = ndk::SharedRefBase::make<QueueCallback>();
+        auto ret = manager_->createEventQueue(cb, &queue);
+        ASSERT_OK(ret);
+        EXPECT_NE(queue, nullptr);
+
+        std::vector<SensorInfo> sensorList;
+        ret = GetSensorList(&sensorList);
+        ASSERT_OK(ret);
+        for (const auto& sensor : sensorList) {
+            if (sensor.flags == 0) continue;
+            ASSERT_OK(queue->enableSensor(sensor.sensorHandle, sensor.minDelayUs, sensor.minDelayUs));
+            // Make sure sensor resources can be cleaned up. b/260017505 for cases not calling disable
+            ASSERT_OK(queue->disableSensor(sensor.sensorHandle));
+        }
+    }
+}
+
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SensorManagerTest);
 INSTANTIATE_TEST_SUITE_P(
     PerInstance, SensorManagerTest,