Skip to content

Commit 057332b

Browse files
Treehugger RobotAndroid (Google) Code Review
Treehugger Robot
authored and
Android (Google) Code Review
committed
Merge "Implement vibration session support" into main
2 parents d24280c + e2b376d commit 057332b

7 files changed

Lines changed: 168 additions & 26 deletions

‎services/vibratorservice/VibratorManagerHalController.cpp‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -150,6 +150,23 @@ HalResult<void> ManagerHalController::cancelSynced() {
150150
return apply(cancelSyncedFn, "cancelSynced");
151151
}
152152

153+
HalResult<std::shared_ptr<Aidl::IVibrationSession>> ManagerHalController::startSession(
154+
const std::vector<int32_t>& ids, const Aidl::VibrationSessionConfig& config,
155+
const std::function<void()>& completionCallback) {
156+
hal_fn<std::shared_ptr<Aidl::IVibrationSession>> startSessionFn =
157+
[&](std::shared_ptr<ManagerHalWrapper> hal) {
158+
return hal->startSession(ids, config, completionCallback);
159+
};
160+
return apply(startSessionFn, "startSession");
161+
}
162+
163+
HalResult<void> ManagerHalController::clearSessions() {
164+
hal_fn<void> clearSessionsFn = [](std::shared_ptr<ManagerHalWrapper> hal) {
165+
return hal->clearSessions();
166+
};
167+
return apply(clearSessionsFn, "clearSessions");
168+
}
169+
153170
}; // namespace vibrator
154171

155172
}; // namespace android

‎services/vibratorservice/VibratorManagerHalWrapper.cpp‎

Lines changed: 39 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,30 @@ namespace vibrator {
2929
constexpr int32_t SINGLE_VIBRATOR_ID = 0;
3030
const constexpr char* MISSING_VIBRATOR_MESSAGE_PREFIX = "No vibrator with id=";
3131

32+
HalResult<void> ManagerHalWrapper::prepareSynced(const std::vector<int32_t>&) {
33+
return HalResult<void>::unsupported();
34+
}
35+
36+
HalResult<void> ManagerHalWrapper::triggerSynced(const std::function<void()>&) {
37+
return HalResult<void>::unsupported();
38+
}
39+
40+
HalResult<void> ManagerHalWrapper::cancelSynced() {
41+
return HalResult<void>::unsupported();
42+
}
43+
44+
HalResult<std::shared_ptr<Aidl::IVibrationSession>> ManagerHalWrapper::startSession(
45+
const std::vector<int32_t>&, const Aidl::VibrationSessionConfig&,
46+
const std::function<void()>&) {
47+
return HalResult<std::shared_ptr<Aidl::IVibrationSession>>::unsupported();
48+
}
49+
50+
HalResult<void> ManagerHalWrapper::clearSessions() {
51+
return HalResult<void>::unsupported();
52+
}
53+
54+
// -------------------------------------------------------------------------------------------------
55+
3256
HalResult<void> LegacyManagerHalWrapper::ping() {
3357
auto pingFn = [](HalWrapper* hal) { return hal->ping(); };
3458
return mController->doWithRetry<void>(pingFn, "ping");
@@ -59,18 +83,6 @@ HalResult<std::shared_ptr<HalController>> LegacyManagerHalWrapper::getVibrator(i
5983
(MISSING_VIBRATOR_MESSAGE_PREFIX + std::to_string(id)).c_str());
6084
}
6185

62-
HalResult<void> LegacyManagerHalWrapper::prepareSynced(const std::vector<int32_t>&) {
63-
return HalResult<void>::unsupported();
64-
}
65-
66-
HalResult<void> LegacyManagerHalWrapper::triggerSynced(const std::function<void()>&) {
67-
return HalResult<void>::unsupported();
68-
}
69-
70-
HalResult<void> LegacyManagerHalWrapper::cancelSynced() {
71-
return HalResult<void>::unsupported();
72-
}
73-
7486
// -------------------------------------------------------------------------------------------------
7587

7688
std::shared_ptr<HalWrapper> AidlManagerHalWrapper::connectToVibrator(
@@ -186,6 +198,17 @@ HalResult<void> AidlManagerHalWrapper::triggerSynced(
186198
return HalResultFactory::fromStatus(getHal()->triggerSynced(cb));
187199
}
188200

201+
HalResult<std::shared_ptr<Aidl::IVibrationSession>> AidlManagerHalWrapper::startSession(
202+
const std::vector<int32_t>& ids, const Aidl::VibrationSessionConfig& config,
203+
const std::function<void()>& completionCallback) {
204+
auto cb = ndk::SharedRefBase::make<HalCallbackWrapper>(completionCallback);
205+
std::shared_ptr<Aidl::IVibrationSession> session;
206+
auto status = getHal()->startSession(ids, config, cb, &session);
207+
return HalResultFactory::fromStatus<std::shared_ptr<Aidl::IVibrationSession>>(std::move(status),
208+
std::move(
209+
session));
210+
}
211+
189212
HalResult<void> AidlManagerHalWrapper::cancelSynced() {
190213
auto ret = HalResultFactory::fromStatus(getHal()->cancelSynced());
191214
if (ret.isOk()) {
@@ -200,6 +223,10 @@ HalResult<void> AidlManagerHalWrapper::cancelSynced() {
200223
return ret;
201224
}
202225

226+
HalResult<void> AidlManagerHalWrapper::clearSessions() {
227+
return HalResultFactory::fromStatus(getHal()->clearSessions());
228+
}
229+
203230
std::shared_ptr<Aidl::IVibratorManager> AidlManagerHalWrapper::getHal() {
204231
std::lock_guard<std::mutex> lock(mHandleMutex);
205232
return mHandle;

‎services/vibratorservice/include/vibratorservice/VibratorManagerHalController.h‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -62,6 +62,10 @@ class ManagerHalController : public ManagerHalWrapper {
6262
HalResult<void> prepareSynced(const std::vector<int32_t>& ids) override final;
6363
HalResult<void> triggerSynced(const std::function<void()>& completionCallback) override final;
6464
HalResult<void> cancelSynced() override final;
65+
HalResult<std::shared_ptr<IVibrationSession>> startSession(
66+
const std::vector<int32_t>& ids, const VibrationSessionConfig& config,
67+
const std::function<void()>& completionCallback) override final;
68+
HalResult<void> clearSessions() override final;
6569

6670
private:
6771
Connector mConnector;

‎services/vibratorservice/include/vibratorservice/VibratorManagerHalWrapper.h‎

Lines changed: 16 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,8 @@ enum class ManagerCapabilities : int32_t {
3838
aidl::android::hardware::vibrator::IVibratorManager::CAP_MIXED_TRIGGER_PERFORM,
3939
MIXED_TRIGGER_COMPOSE =
4040
aidl::android::hardware::vibrator::IVibratorManager::CAP_MIXED_TRIGGER_COMPOSE,
41-
TRIGGER_CALLBACK = aidl::android::hardware::vibrator::IVibratorManager::CAP_TRIGGER_CALLBACK
41+
TRIGGER_CALLBACK = aidl::android::hardware::vibrator::IVibratorManager::CAP_TRIGGER_CALLBACK,
42+
START_SESSIONS = aidl::android::hardware::vibrator::IVibratorManager::CAP_START_SESSIONS
4243
};
4344

4445
inline ManagerCapabilities operator|(ManagerCapabilities lhs, ManagerCapabilities rhs) {
@@ -64,6 +65,9 @@ inline ManagerCapabilities& operator&=(ManagerCapabilities& lhs, ManagerCapabili
6465
// Wrapper for VibratorManager HAL handlers.
6566
class ManagerHalWrapper {
6667
public:
68+
using IVibrationSession = aidl::android::hardware::vibrator::IVibrationSession;
69+
using VibrationSessionConfig = aidl::android::hardware::vibrator::VibrationSessionConfig;
70+
6771
ManagerHalWrapper() = default;
6872
virtual ~ManagerHalWrapper() = default;
6973

@@ -78,9 +82,13 @@ class ManagerHalWrapper {
7882
virtual HalResult<std::vector<int32_t>> getVibratorIds() = 0;
7983
virtual HalResult<std::shared_ptr<HalController>> getVibrator(int32_t id) = 0;
8084

81-
virtual HalResult<void> prepareSynced(const std::vector<int32_t>& ids) = 0;
82-
virtual HalResult<void> triggerSynced(const std::function<void()>& completionCallback) = 0;
83-
virtual HalResult<void> cancelSynced() = 0;
85+
virtual HalResult<void> prepareSynced(const std::vector<int32_t>& ids);
86+
virtual HalResult<void> triggerSynced(const std::function<void()>& completionCallback);
87+
virtual HalResult<void> cancelSynced();
88+
virtual HalResult<std::shared_ptr<IVibrationSession>> startSession(
89+
const std::vector<int32_t>& ids, const VibrationSessionConfig& config,
90+
const std::function<void()>& completionCallback);
91+
virtual HalResult<void> clearSessions();
8492
};
8593

8694
// Wrapper for the VibratorManager over single Vibrator HAL.
@@ -98,10 +106,6 @@ class LegacyManagerHalWrapper : public ManagerHalWrapper {
98106
HalResult<std::vector<int32_t>> getVibratorIds() override final;
99107
HalResult<std::shared_ptr<HalController>> getVibrator(int32_t id) override final;
100108

101-
HalResult<void> prepareSynced(const std::vector<int32_t>& ids) override final;
102-
HalResult<void> triggerSynced(const std::function<void()>& completionCallback) override final;
103-
HalResult<void> cancelSynced() override final;
104-
105109
private:
106110
const std::shared_ptr<HalController> mController;
107111
};
@@ -126,6 +130,10 @@ class AidlManagerHalWrapper : public ManagerHalWrapper {
126130
HalResult<void> prepareSynced(const std::vector<int32_t>& ids) override final;
127131
HalResult<void> triggerSynced(const std::function<void()>& completionCallback) override final;
128132
HalResult<void> cancelSynced() override final;
133+
HalResult<std::shared_ptr<IVibrationSession>> startSession(
134+
const std::vector<int32_t>& ids, const VibrationSessionConfig& config,
135+
const std::function<void()>& completionCallback) override final;
136+
HalResult<void> clearSessions() override final;
129137

130138
private:
131139
std::mutex mHandleMutex;

‎services/vibratorservice/test/VibratorManagerHalControllerTest.cpp‎

Lines changed: 34 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -27,13 +27,16 @@
2727
#include "test_mocks.h"
2828
#include "test_utils.h"
2929

30+
using aidl::android::hardware::vibrator::IVibrationSession;
31+
using aidl::android::hardware::vibrator::VibrationSessionConfig;
3032
using android::vibrator::HalController;
3133

3234
using namespace android;
3335
using namespace testing;
3436

3537
static constexpr int MAX_ATTEMPTS = 2;
3638
static const std::vector<int32_t> VIBRATOR_IDS = {1, 2};
39+
static const VibrationSessionConfig SESSION_CONFIG;
3740
static constexpr int VIBRATOR_ID = 1;
3841

3942
// -------------------------------------------------------------------------------------------------
@@ -52,6 +55,11 @@ class MockManagerHalWrapper : public vibrator::ManagerHalWrapper {
5255
MOCK_METHOD(vibrator::HalResult<void>, triggerSynced,
5356
(const std::function<void()>& completionCallback), (override));
5457
MOCK_METHOD(vibrator::HalResult<void>, cancelSynced, (), (override));
58+
MOCK_METHOD(vibrator::HalResult<std::shared_ptr<IVibrationSession>>, startSession,
59+
(const std::vector<int32_t>& ids, const VibrationSessionConfig& s,
60+
const std::function<void()>& completionCallback),
61+
(override));
62+
MOCK_METHOD(vibrator::HalResult<void>, clearSessions, (), (override));
5563
};
5664

5765
// -------------------------------------------------------------------------------------------------
@@ -79,7 +87,8 @@ class VibratorManagerHalControllerTest : public Test {
7987
void setHalExpectations(int32_t cardinality, vibrator::HalResult<void> voidResult,
8088
vibrator::HalResult<vibrator::ManagerCapabilities> capabilitiesResult,
8189
vibrator::HalResult<std::vector<int32_t>> idsResult,
82-
vibrator::HalResult<std::shared_ptr<HalController>> vibratorResult) {
90+
vibrator::HalResult<std::shared_ptr<HalController>> vibratorResult,
91+
vibrator::HalResult<std::shared_ptr<IVibrationSession>> sessionResult) {
8392
EXPECT_CALL(*mMockHal.get(), ping())
8493
.Times(Exactly(cardinality))
8594
.WillRepeatedly(Return(voidResult));
@@ -101,10 +110,16 @@ class VibratorManagerHalControllerTest : public Test {
101110
EXPECT_CALL(*mMockHal.get(), cancelSynced())
102111
.Times(Exactly(cardinality))
103112
.WillRepeatedly(Return(voidResult));
113+
EXPECT_CALL(*mMockHal.get(), startSession(_, _, _))
114+
.Times(Exactly(cardinality))
115+
.WillRepeatedly(Return(sessionResult));
116+
EXPECT_CALL(*mMockHal.get(), clearSessions())
117+
.Times(Exactly(cardinality))
118+
.WillRepeatedly(Return(voidResult));
104119

105120
if (cardinality > 1) {
106121
// One reconnection for each retry.
107-
EXPECT_CALL(*mMockHal.get(), tryReconnect()).Times(Exactly(7 * (cardinality - 1)));
122+
EXPECT_CALL(*mMockHal.get(), tryReconnect()).Times(Exactly(9 * (cardinality - 1)));
108123
} else {
109124
EXPECT_CALL(*mMockHal.get(), tryReconnect()).Times(Exactly(0));
110125
}
@@ -127,7 +142,8 @@ TEST_F(VibratorManagerHalControllerTest, TestApiCallsAreForwardedToHal) {
127142
vibrator::HalResult<vibrator::ManagerCapabilities>::ok(
128143
vibrator::ManagerCapabilities::SYNC),
129144
vibrator::HalResult<std::vector<int32_t>>::ok(VIBRATOR_IDS),
130-
vibrator::HalResult<std::shared_ptr<HalController>>::ok(nullptr));
145+
vibrator::HalResult<std::shared_ptr<HalController>>::ok(nullptr),
146+
vibrator::HalResult<std::shared_ptr<IVibrationSession>>::ok(nullptr));
131147

132148
ASSERT_TRUE(mController->ping().isOk());
133149

@@ -146,6 +162,8 @@ TEST_F(VibratorManagerHalControllerTest, TestApiCallsAreForwardedToHal) {
146162
ASSERT_TRUE(mController->prepareSynced(VIBRATOR_IDS).isOk());
147163
ASSERT_TRUE(mController->triggerSynced([]() {}).isOk());
148164
ASSERT_TRUE(mController->cancelSynced().isOk());
165+
ASSERT_TRUE(mController->startSession(VIBRATOR_IDS, SESSION_CONFIG, []() {}).isOk());
166+
ASSERT_TRUE(mController->clearSessions().isOk());
149167

150168
ASSERT_EQ(1, mConnectCounter);
151169
}
@@ -154,7 +172,8 @@ TEST_F(VibratorManagerHalControllerTest, TestUnsupportedApiResultDoesNotResetHal
154172
setHalExpectations(/* cardinality= */ 1, vibrator::HalResult<void>::unsupported(),
155173
vibrator::HalResult<vibrator::ManagerCapabilities>::unsupported(),
156174
vibrator::HalResult<std::vector<int32_t>>::unsupported(),
157-
vibrator::HalResult<std::shared_ptr<HalController>>::unsupported());
175+
vibrator::HalResult<std::shared_ptr<HalController>>::unsupported(),
176+
vibrator::HalResult<std::shared_ptr<IVibrationSession>>::unsupported());
158177

159178
ASSERT_TRUE(mController->ping().isUnsupported());
160179
ASSERT_TRUE(mController->getCapabilities().isUnsupported());
@@ -163,6 +182,8 @@ TEST_F(VibratorManagerHalControllerTest, TestUnsupportedApiResultDoesNotResetHal
163182
ASSERT_TRUE(mController->prepareSynced(VIBRATOR_IDS).isUnsupported());
164183
ASSERT_TRUE(mController->triggerSynced([]() {}).isUnsupported());
165184
ASSERT_TRUE(mController->cancelSynced().isUnsupported());
185+
ASSERT_TRUE(mController->startSession(VIBRATOR_IDS, SESSION_CONFIG, []() {}).isUnsupported());
186+
ASSERT_TRUE(mController->clearSessions().isUnsupported());
166187

167188
ASSERT_EQ(1, mConnectCounter);
168189
}
@@ -171,7 +192,8 @@ TEST_F(VibratorManagerHalControllerTest, TestOperationFailedApiResultDoesNotRese
171192
setHalExpectations(/* cardinality= */ 1, vibrator::HalResult<void>::failed("msg"),
172193
vibrator::HalResult<vibrator::ManagerCapabilities>::failed("msg"),
173194
vibrator::HalResult<std::vector<int32_t>>::failed("msg"),
174-
vibrator::HalResult<std::shared_ptr<HalController>>::failed("msg"));
195+
vibrator::HalResult<std::shared_ptr<HalController>>::failed("msg"),
196+
vibrator::HalResult<std::shared_ptr<IVibrationSession>>::failed("msg"));
175197

176198
ASSERT_TRUE(mController->ping().isFailed());
177199
ASSERT_TRUE(mController->getCapabilities().isFailed());
@@ -180,6 +202,8 @@ TEST_F(VibratorManagerHalControllerTest, TestOperationFailedApiResultDoesNotRese
180202
ASSERT_TRUE(mController->prepareSynced(VIBRATOR_IDS).isFailed());
181203
ASSERT_TRUE(mController->triggerSynced([]() {}).isFailed());
182204
ASSERT_TRUE(mController->cancelSynced().isFailed());
205+
ASSERT_TRUE(mController->startSession(VIBRATOR_IDS, SESSION_CONFIG, []() {}).isFailed());
206+
ASSERT_TRUE(mController->clearSessions().isFailed());
183207

184208
ASSERT_EQ(1, mConnectCounter);
185209
}
@@ -188,7 +212,9 @@ TEST_F(VibratorManagerHalControllerTest, TestTransactionFailedApiResultResetsHal
188212
setHalExpectations(MAX_ATTEMPTS, vibrator::HalResult<void>::transactionFailed("m"),
189213
vibrator::HalResult<vibrator::ManagerCapabilities>::transactionFailed("m"),
190214
vibrator::HalResult<std::vector<int32_t>>::transactionFailed("m"),
191-
vibrator::HalResult<std::shared_ptr<HalController>>::transactionFailed("m"));
215+
vibrator::HalResult<std::shared_ptr<HalController>>::transactionFailed("m"),
216+
vibrator::HalResult<std::shared_ptr<IVibrationSession>>::transactionFailed(
217+
"m"));
192218

193219
ASSERT_TRUE(mController->ping().isFailed());
194220
ASSERT_TRUE(mController->getCapabilities().isFailed());
@@ -197,6 +223,8 @@ TEST_F(VibratorManagerHalControllerTest, TestTransactionFailedApiResultResetsHal
197223
ASSERT_TRUE(mController->prepareSynced(VIBRATOR_IDS).isFailed());
198224
ASSERT_TRUE(mController->triggerSynced([]() {}).isFailed());
199225
ASSERT_TRUE(mController->cancelSynced().isFailed());
226+
ASSERT_TRUE(mController->startSession(VIBRATOR_IDS, SESSION_CONFIG, []() {}).isFailed());
227+
ASSERT_TRUE(mController->clearSessions().isFailed());
200228

201229
ASSERT_EQ(1, mConnectCounter);
202230
}

‎services/vibratorservice/test/VibratorManagerHalWrapperAidlTest.cpp‎

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -69,12 +69,25 @@ class MockIVibratorManager : public IVibratorManager {
6969
MOCK_METHOD(bool, isRemote, (), (override));
7070
};
7171

72+
class MockIVibrationSession : public IVibrationSession {
73+
public:
74+
MockIVibrationSession() = default;
75+
76+
MOCK_METHOD(ndk::ScopedAStatus, close, (), (override));
77+
MOCK_METHOD(ndk::ScopedAStatus, abort, (), (override));
78+
MOCK_METHOD(ndk::ScopedAStatus, getInterfaceVersion, (int32_t*), (override));
79+
MOCK_METHOD(ndk::ScopedAStatus, getInterfaceHash, (std::string*), (override));
80+
MOCK_METHOD(ndk::SpAIBinder, asBinder, (), (override));
81+
MOCK_METHOD(bool, isRemote, (), (override));
82+
};
83+
7284
// -------------------------------------------------------------------------------------------------
7385

7486
class VibratorManagerHalWrapperAidlTest : public Test {
7587
public:
7688
void SetUp() override {
7789
mMockVibrator = ndk::SharedRefBase::make<StrictMock<vibrator::MockIVibrator>>();
90+
mMockSession = ndk::SharedRefBase::make<StrictMock<MockIVibrationSession>>();
7891
mMockHal = ndk::SharedRefBase::make<StrictMock<MockIVibratorManager>>();
7992
mMockScheduler = std::make_shared<StrictMock<vibrator::MockCallbackScheduler>>();
8093
mWrapper = std::make_unique<vibrator::AidlManagerHalWrapper>(mMockScheduler, mMockHal);
@@ -86,11 +99,13 @@ class VibratorManagerHalWrapperAidlTest : public Test {
8699
std::unique_ptr<vibrator::ManagerHalWrapper> mWrapper = nullptr;
87100
std::shared_ptr<StrictMock<MockIVibratorManager>> mMockHal = nullptr;
88101
std::shared_ptr<StrictMock<vibrator::MockIVibrator>> mMockVibrator = nullptr;
102+
std::shared_ptr<StrictMock<MockIVibrationSession>> mMockSession = nullptr;
89103
};
90104

91105
// -------------------------------------------------------------------------------------------------
92106

93107
static const std::vector<int32_t> kVibratorIds = {1, 2};
108+
static const VibrationSessionConfig kSessionConfig;
94109
static constexpr int kVibratorId = 1;
95110

96111
TEST_F(VibratorManagerHalWrapperAidlTest, TestGetCapabilitiesDoesNotCacheFailedResult) {
@@ -319,3 +334,35 @@ TEST_F(VibratorManagerHalWrapperAidlTest, TestCancelSyncedReloadsAllControllers)
319334
ASSERT_TRUE(mWrapper->getVibratorIds().isOk());
320335
ASSERT_TRUE(mWrapper->cancelSynced().isOk());
321336
}
337+
338+
TEST_F(VibratorManagerHalWrapperAidlTest, TestStartSession) {
339+
EXPECT_CALL(*mMockHal.get(), startSession(_, _, _, _))
340+
.Times(Exactly(3))
341+
.WillOnce(Return(ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_TRANSACTION)))
342+
.WillOnce(Return(ndk::ScopedAStatus::fromExceptionCode(EX_SECURITY)))
343+
.WillOnce(
344+
DoAll(DoAll(SetArgPointee<3>(mMockSession), Return(ndk::ScopedAStatus::ok()))));
345+
346+
std::unique_ptr<int32_t> callbackCounter = std::make_unique<int32_t>();
347+
auto callback = vibrator::TestFactory::createCountingCallback(callbackCounter.get());
348+
349+
ASSERT_TRUE(mWrapper->startSession(kVibratorIds, kSessionConfig, callback).isUnsupported());
350+
ASSERT_TRUE(mWrapper->startSession(kVibratorIds, kSessionConfig, callback).isFailed());
351+
352+
auto result = mWrapper->startSession(kVibratorIds, kSessionConfig, callback);
353+
ASSERT_TRUE(result.isOk());
354+
ASSERT_NE(nullptr, result.value().get());
355+
ASSERT_EQ(0, *callbackCounter.get());
356+
}
357+
358+
TEST_F(VibratorManagerHalWrapperAidlTest, TestClearSessions) {
359+
EXPECT_CALL(*mMockHal.get(), clearSessions())
360+
.Times(Exactly(3))
361+
.WillOnce(Return(ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_TRANSACTION)))
362+
.WillOnce(Return(ndk::ScopedAStatus::fromExceptionCode(EX_SECURITY)))
363+
.WillOnce(Return(ndk::ScopedAStatus::ok()));
364+
365+
ASSERT_TRUE(mWrapper->clearSessions().isUnsupported());
366+
ASSERT_TRUE(mWrapper->clearSessions().isFailed());
367+
ASSERT_TRUE(mWrapper->clearSessions().isOk());
368+
}

0 commit comments

Comments
 (0)