1 /*
2 * Copyright (C) 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "app_timeout_test.h"
18
19 #include <gtest/gtest.h>
20 #include <string.h>
21 #include <cstdint>
22 #include <thread>
23
24 #include "chpp/app.h"
25 #include "chpp/clients.h"
26 #include "chpp/clients/gnss.h"
27 #include "chpp/clients/wifi.h"
28 #include "chpp/clients/wwan.h"
29 #include "chpp/macros.h"
30 #include "chpp/memory.h"
31 #include "chpp/platform/platform_link.h"
32 #include "chpp/platform/utils.h"
33 #include "chpp/services.h"
34 #include "chpp/time.h"
35 #include "chpp/transport.h"
36 #include "chre/pal/wwan.h"
37
38 namespace chre {
39 namespace {
40
41 #define TEST_UUID \
42 { \
43 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
44 0x00, 0x00, 0x00, 0x12 \
45 }
46
47 // Number of requests supported by the client and the service.
48 constexpr uint16_t kNumCommands = 3;
49
50 struct ClientState {
51 struct ChppEndpointState chppClientState;
52 struct ChppOutgoingRequestState outReqStates[kNumCommands];
53 };
54
55 constexpr struct ChppClient kClient = {
56 .descriptor.uuid = TEST_UUID,
57 .descriptor.version.major = 1,
58 .descriptor.version.minor = 0,
59 .descriptor.version.patch = 0,
60 .outReqCount = kNumCommands,
61 .minLength = sizeof(struct ChppAppHeader),
62 };
63
64 struct ServiceState {
65 struct ChppEndpointState chppServiceState;
66 struct ChppOutgoingRequestState outReqStates[kNumCommands];
67 };
68
69 const struct ChppService kService = {
70 .descriptor.uuid = TEST_UUID,
71 .descriptor.name = "Test",
72 .descriptor.version.major = 1,
73 .descriptor.version.minor = 0,
74 .descriptor.version.patch = 0,
75 .outReqCount = kNumCommands,
76 .minLength = sizeof(struct ChppAppHeader),
77 };
78
ValidateClientStateAndReqState(struct ChppEndpointState * clientState,const struct ChppAppHeader * request)79 void ValidateClientStateAndReqState(struct ChppEndpointState *clientState,
80 const struct ChppAppHeader *request) {
81 ASSERT_NE(clientState, nullptr);
82 const uint8_t clientIdx = clientState->index;
83
84 ASSERT_NE(clientState->appContext, nullptr);
85 ASSERT_NE(clientState->appContext->registeredClients, nullptr);
86 ASSERT_NE(clientState->appContext->registeredClients[clientIdx], nullptr);
87 ASSERT_LT(request->command,
88 clientState->appContext->registeredClients[clientIdx]->outReqCount);
89 ASSERT_NE(clientState->appContext->registeredClientStates[clientIdx],
90 nullptr);
91 ASSERT_NE(
92 clientState->appContext->registeredClientStates[clientIdx]->outReqStates,
93 nullptr);
94 ASSERT_NE(clientState->appContext->registeredClientStates[clientIdx]->context,
95 nullptr);
96 }
97
ValidateServiceStateAndReqState(struct ChppEndpointState * serviceState,const struct ChppAppHeader * request)98 void ValidateServiceStateAndReqState(struct ChppEndpointState *serviceState,
99 const struct ChppAppHeader *request) {
100 ASSERT_NE(serviceState, nullptr);
101 const uint8_t serviceIdx = serviceState->index;
102
103 ASSERT_NE(serviceState->appContext, nullptr);
104 ASSERT_NE(serviceState->appContext->registeredServices, nullptr);
105 ASSERT_NE(serviceState->appContext->registeredServices[serviceIdx], nullptr);
106 ASSERT_LT(
107 request->command,
108 serviceState->appContext->registeredServices[serviceIdx]->outReqCount);
109 ASSERT_NE(serviceState->appContext->registeredServiceStates[serviceIdx],
110 nullptr);
111 ASSERT_NE(serviceState->appContext->registeredServiceStates[serviceIdx]
112 ->outReqStates,
113 nullptr);
114 ASSERT_NE(
115 serviceState->appContext->registeredServiceStates[serviceIdx]->context,
116 nullptr);
117 }
118
validateTimeout(uint64_t timeoutTimeNs,uint64_t expectedTimeNs)119 void validateTimeout(uint64_t timeoutTimeNs, uint64_t expectedTimeNs) {
120 constexpr uint64_t kJitterNs = 10 * CHPP_NSEC_PER_MSEC;
121
122 if (expectedTimeNs == CHPP_TIME_MAX) {
123 EXPECT_EQ(timeoutTimeNs, expectedTimeNs);
124 } else {
125 EXPECT_GE(timeoutTimeNs, expectedTimeNs);
126 EXPECT_LE(timeoutTimeNs, expectedTimeNs + kJitterNs);
127 }
128 }
129
validateTimeoutResponse(const struct ChppAppHeader * request,const struct ChppAppHeader * response)130 void validateTimeoutResponse(const struct ChppAppHeader *request,
131 const struct ChppAppHeader *response) {
132 ASSERT_NE(request, nullptr);
133 ASSERT_NE(response, nullptr);
134
135 EXPECT_EQ(response->handle, request->handle);
136
137 EXPECT_EQ(response->type, request->type == CHPP_MESSAGE_TYPE_CLIENT_REQUEST
138 ? CHPP_MESSAGE_TYPE_SERVICE_RESPONSE
139 : CHPP_MESSAGE_TYPE_CLIENT_RESPONSE);
140 EXPECT_EQ(response->transaction, request->transaction);
141 EXPECT_EQ(response->error, CHPP_APP_ERROR_TIMEOUT);
142 EXPECT_EQ(response->command, request->command);
143 }
144
145 /**
146 * Test timeout for client and service side requests.
147 *
148 * The test parameter is:
149 * - CHPP_MESSAGE_TYPE_CLIENT_REQUEST for client side requests
150 * - CHPP_MESSAGE_TYPE_SERVICE_REQUEST for service side requests
151 */
152 class TimeoutParamTest : public testing::TestWithParam<ChppMessageType> {
153 protected:
SetUp()154 void SetUp() override {
155 chppClearTotalAllocBytes();
156
157 memset(&mClientLinkContext, 0, sizeof(mClientLinkContext));
158 memset(&mServiceLinkContext, 0, sizeof(mServiceLinkContext));
159
160 mServiceLinkContext.isLinkActive = true;
161 mServiceLinkContext.remoteLinkState = &mClientLinkContext;
162 mServiceLinkContext.rxInRemoteEndpointWorker = false;
163
164 mClientLinkContext.isLinkActive = true;
165 mClientLinkContext.remoteLinkState = &mServiceLinkContext;
166 mClientLinkContext.rxInRemoteEndpointWorker = false;
167
168 // No default clients/services.
169 struct ChppClientServiceSet set;
170 memset(&set, 0, sizeof(set));
171
172 const struct ChppLinkApi *linkApi = getLinuxLinkApi();
173
174 // Init client side.
175 chppTransportInit(&mClientTransportContext, &mClientAppContext,
176 &mClientLinkContext, linkApi);
177 mClientTransportContext.resetState = CHPP_RESET_STATE_NONE;
178 chppAppInitWithClientServiceSet(&mClientAppContext,
179 &mClientTransportContext, set);
180
181 // Init service side.
182 chppTransportInit(&mServiceTransportContext, &mServiceAppContext,
183 &mServiceLinkContext, linkApi);
184 mServiceTransportContext.resetState = CHPP_RESET_STATE_NONE;
185 chppAppInitWithClientServiceSet(&mServiceAppContext,
186 &mServiceTransportContext, set);
187
188 // Bring up the client
189 memset(&mClientState, 0, sizeof(mClientState));
190 chppRegisterClient(&mClientAppContext, &mClientState,
191 &mClientState.chppClientState,
192 &mClientState.outReqStates[0], &kClient);
193
194 // Bring up the service
195 memset(&mServiceState, 0, sizeof(mServiceState));
196 chppRegisterService(&mServiceAppContext, &mServiceState,
197 &mServiceState.chppServiceState,
198 &mServiceState.outReqStates[0], &kService);
199
200 mClientLinkContext.linkEstablished = true;
201 mServiceLinkContext.linkEstablished = true;
202
203 chppClientInit(&mClientState.chppClientState,
204 CHPP_HANDLE_NEGOTIATED_RANGE_START);
205 }
206
TearDown()207 void TearDown() override {
208 chppAppDeinit(&mClientAppContext);
209 chppTransportDeinit(&mClientTransportContext);
210 chppClientDeinit(&mClientState.chppClientState);
211
212 chppAppDeinit(&mServiceAppContext);
213 chppTransportDeinit(&mServiceTransportContext);
214
215 EXPECT_EQ(chppGetTotalAllocBytes(), 0);
216 }
217
AllocRequestCommand(uint16_t command)218 struct ChppAppHeader *AllocRequestCommand(uint16_t command) {
219 return GetParam() == CHPP_MESSAGE_TYPE_CLIENT_REQUEST
220 ? chppAllocClientRequestCommand(&mClientState.chppClientState,
221 command)
222 : chppAllocServiceRequestCommand(&mServiceState.chppServiceState,
223 command);
224 }
225
TimestampOutgoingRequest(struct ChppAppHeader * request,uint64_t timeoutNs)226 void TimestampOutgoingRequest(struct ChppAppHeader *request,
227 uint64_t timeoutNs) {
228 CHPP_NOT_NULL(request);
229
230 const uint16_t command = request->command;
231
232 if (GetParam() == CHPP_MESSAGE_TYPE_CLIENT_REQUEST) {
233 chppTimestampOutgoingRequest(&mClientAppContext,
234 &mClientState.outReqStates[command], request,
235 timeoutNs);
236 } else {
237 chppTimestampOutgoingRequest(&mServiceAppContext,
238 &mServiceState.outReqStates[command],
239 request, timeoutNs);
240 }
241 }
242
TimestampIncomingResponse(struct ChppAppHeader * response)243 bool TimestampIncomingResponse(struct ChppAppHeader *response) {
244 CHPP_NOT_NULL(response);
245
246 const uint16_t command = response->command;
247
248 if (GetParam() == CHPP_MESSAGE_TYPE_CLIENT_REQUEST) {
249 return chppTimestampIncomingResponse(
250 &mClientAppContext, &mClientState.outReqStates[command], response);
251 }
252 return chppTimestampIncomingResponse(
253 &mServiceAppContext, &mServiceState.outReqStates[command], response);
254 }
255
GetNextRequestTimeoutNs(void)256 uint64_t GetNextRequestTimeoutNs(void) {
257 return GetParam() == CHPP_MESSAGE_TYPE_CLIENT_REQUEST
258 ? mClientAppContext.nextClientRequestTimeoutNs
259 : mServiceAppContext.nextServiceRequestTimeoutNs;
260 }
261
GetTimeoutResponse(void)262 struct ChppAppHeader *GetTimeoutResponse(void) {
263 return GetParam() == CHPP_MESSAGE_TYPE_CLIENT_REQUEST
264 ? chppTransportGetRequestTimeoutResponse(
265 &mClientTransportContext, CHPP_ENDPOINT_CLIENT)
266 : chppTransportGetRequestTimeoutResponse(
267 &mServiceTransportContext, CHPP_ENDPOINT_SERVICE);
268 }
269
ValidateRequestState(struct ChppAppHeader * request)270 void ValidateRequestState(struct ChppAppHeader *request) {
271 CHPP_NOT_NULL(request);
272 if (GetParam() == CHPP_MESSAGE_TYPE_CLIENT_REQUEST) {
273 ValidateClientStateAndReqState(&mClientState.chppClientState, request);
274 } else {
275 ValidateServiceStateAndReqState(&mServiceState.chppServiceState, request);
276 }
277 }
278
RegisterAndValidateRequestForTimeout(struct ChppAppHeader * request,uint64_t kTimeoutNs,uint64_t expectedTimeNs)279 void RegisterAndValidateRequestForTimeout(struct ChppAppHeader *request,
280 uint64_t kTimeoutNs,
281 uint64_t expectedTimeNs) {
282 CHPP_NOT_NULL(request);
283 ValidateRequestState(request);
284 TimestampOutgoingRequest(request, kTimeoutNs);
285
286 validateTimeout(GetNextRequestTimeoutNs(), expectedTimeNs);
287 }
288
RegisterAndValidateResponseForTimeout(struct ChppAppHeader * request,uint64_t expectedTimeNs)289 void RegisterAndValidateResponseForTimeout(struct ChppAppHeader *request,
290 uint64_t expectedTimeNs) {
291 CHPP_NOT_NULL(request);
292
293 struct ChppAppHeader *response =
294 chppAllocResponse(request, sizeof(*request));
295
296 ValidateRequestState(request);
297 TimestampIncomingResponse(response);
298
299 validateTimeout(GetNextRequestTimeoutNs(), expectedTimeNs);
300
301 chppFree(response);
302 }
303
304 // Client side.
305 ChppLinuxLinkState mClientLinkContext = {};
306 ChppTransportState mClientTransportContext = {};
307 ChppAppState mClientAppContext = {};
308 ClientState mClientState;
309
310 // Service side
311 ChppLinuxLinkState mServiceLinkContext = {};
312 ChppTransportState mServiceTransportContext = {};
313 ChppAppState mServiceAppContext = {};
314 ServiceState mServiceState;
315 };
316
317 // Simulates a request and a response.
318 // There should be no error as the timeout is infinite.
TEST_P(TimeoutParamTest,RequestResponseTimestampValid)319 TEST_P(TimeoutParamTest, RequestResponseTimestampValid) {
320 struct ChppAppHeader *request = AllocRequestCommand(0 /* command */);
321 ASSERT_NE(request, nullptr);
322 TimestampOutgoingRequest(request, CHPP_REQUEST_TIMEOUT_INFINITE);
323
324 struct ChppAppHeader *response = chppAllocResponse(request, sizeof(*request));
325 EXPECT_TRUE(TimestampIncomingResponse(response));
326
327 chppFree(request);
328 chppFree(response);
329 }
330
331 // Simulates a single request with 2 responses.
TEST_P(TimeoutParamTest,RequestResponseTimestampDuplicate)332 TEST_P(TimeoutParamTest, RequestResponseTimestampDuplicate) {
333 struct ChppAppHeader *request = AllocRequestCommand(0 /* command */);
334 ASSERT_NE(request, nullptr);
335 TimestampOutgoingRequest(request, CHPP_REQUEST_TIMEOUT_INFINITE);
336
337 struct ChppAppHeader *response = chppAllocResponse(request, sizeof(*request));
338
339 // The first response has no error.
340 EXPECT_TRUE(TimestampIncomingResponse(response));
341
342 // The second response errors as one response has already been received.
343 EXPECT_FALSE(TimestampIncomingResponse(response));
344
345 chppFree(request);
346 chppFree(response);
347 }
348
349 // Simulates a response to a request that has not been timestamped.
TEST_P(TimeoutParamTest,RequestResponseTimestampInvalidId)350 TEST_P(TimeoutParamTest, RequestResponseTimestampInvalidId) {
351 constexpr uint16_t command = 0;
352
353 struct ChppAppHeader *request1 = AllocRequestCommand(command);
354 ASSERT_NE(request1, nullptr);
355 TimestampOutgoingRequest(request1, CHPP_REQUEST_TIMEOUT_INFINITE);
356
357 struct ChppAppHeader *request2 = AllocRequestCommand(command);
358 ASSERT_NE(request2, nullptr);
359
360 // We expect a response for req but get a response for newReq.
361 // That is an error (the transaction does not match).
362 struct ChppAppHeader *response =
363 chppAllocResponse(request2, sizeof(*request1));
364 EXPECT_FALSE(TimestampIncomingResponse(response));
365
366 chppFree(request1);
367 chppFree(request2);
368 chppFree(response);
369 }
370
371 // Make sure the request does not timeout right away.
TEST_P(TimeoutParamTest,RequestTimeoutAddRemoveSingle)372 TEST_P(TimeoutParamTest, RequestTimeoutAddRemoveSingle) {
373 EXPECT_EQ(GetNextRequestTimeoutNs(), CHPP_TIME_MAX);
374
375 struct ChppAppHeader *request = AllocRequestCommand(1 /* command */);
376 ASSERT_NE(request, nullptr);
377
378 const uint64_t timeNs = chppGetCurrentTimeNs();
379 constexpr uint64_t kTimeoutNs = 1000 * CHPP_NSEC_PER_MSEC;
380 RegisterAndValidateRequestForTimeout(request, kTimeoutNs,
381 timeNs + kTimeoutNs);
382
383 // Timeout is not expired yet.
384 EXPECT_EQ(GetTimeoutResponse(), nullptr);
385
386 RegisterAndValidateResponseForTimeout(request, CHPP_TIME_MAX);
387
388 chppFree(request);
389 }
390
TEST_P(TimeoutParamTest,RequestTimeoutAddRemoveMultiple)391 TEST_P(TimeoutParamTest, RequestTimeoutAddRemoveMultiple) {
392 EXPECT_EQ(GetNextRequestTimeoutNs(), CHPP_TIME_MAX);
393
394 struct ChppAppHeader *request1 = AllocRequestCommand(0 /* command */);
395 struct ChppAppHeader *request2 = AllocRequestCommand(1 /* command */);
396 struct ChppAppHeader *request3 = AllocRequestCommand(2 /* command */);
397 ASSERT_NE(request1, nullptr);
398 ASSERT_NE(request2, nullptr);
399 ASSERT_NE(request3, nullptr);
400
401 // kTimeout1Ns is the smallest so it will be the first timeout to expire
402 // for all the requests.
403 const uint64_t time1Ns = chppGetCurrentTimeNs();
404 constexpr uint64_t kTimeout1Ns = 2000 * CHPP_NSEC_PER_MSEC;
405 RegisterAndValidateRequestForTimeout(request1, kTimeout1Ns,
406 time1Ns + kTimeout1Ns);
407
408 const uint64_t time2Ns = chppGetCurrentTimeNs();
409 constexpr uint64_t kTimeout2Ns = 4000 * CHPP_NSEC_PER_MSEC;
410 RegisterAndValidateRequestForTimeout(request2, kTimeout2Ns,
411 time1Ns + kTimeout1Ns);
412
413 const uint64_t time3Ns = chppGetCurrentTimeNs();
414 constexpr uint64_t kTimeout3Ns = 3000 * CHPP_NSEC_PER_MSEC;
415 RegisterAndValidateRequestForTimeout(request3, kTimeout3Ns,
416 time1Ns + kTimeout1Ns);
417
418 RegisterAndValidateResponseForTimeout(request1, time3Ns + kTimeout3Ns);
419
420 // Timeout is not expired yet.
421 EXPECT_EQ(GetTimeoutResponse(), nullptr);
422
423 // kTimeout4Ns is now the smallest timeout.
424 const uint64_t time4Ns = chppGetCurrentTimeNs();
425 constexpr uint64_t kTimeout4Ns = 1000 * CHPP_NSEC_PER_MSEC;
426 RegisterAndValidateRequestForTimeout(request1, kTimeout4Ns,
427 time4Ns + kTimeout4Ns);
428
429 RegisterAndValidateResponseForTimeout(request1, time3Ns + kTimeout3Ns);
430
431 RegisterAndValidateResponseForTimeout(request3, time2Ns + kTimeout2Ns);
432
433 RegisterAndValidateResponseForTimeout(request2, CHPP_TIME_MAX);
434
435 EXPECT_EQ(GetTimeoutResponse(), nullptr);
436
437 chppFree(request1);
438 chppFree(request2);
439 chppFree(request3);
440 }
441
TEST_P(TimeoutParamTest,DuplicateRequestTimeoutResponse)442 TEST_P(TimeoutParamTest, DuplicateRequestTimeoutResponse) {
443 // Sleep padding to make sure we timeout.
444 constexpr auto kTimeoutPadding = std::chrono::milliseconds(50);
445
446 EXPECT_EQ(GetNextRequestTimeoutNs(), CHPP_TIME_MAX);
447
448 struct ChppAppHeader *request = AllocRequestCommand(1 /* command */);
449 ASSERT_NE(request, nullptr);
450
451 // Send the first request.
452 constexpr uint64_t kTimeout1Ns = 20 * CHPP_NSEC_PER_MSEC;
453 const uint64_t kShouldTimeout1AtNs = chppGetCurrentTimeNs() + kTimeout1Ns;
454 RegisterAndValidateRequestForTimeout(request, kTimeout1Ns,
455 kShouldTimeout1AtNs);
456
457 // Override with a new request.
458 constexpr uint64_t kTimeout2Ns = 400 * CHPP_NSEC_PER_MSEC;
459 const uint64_t kShouldTimeout2AtNs = chppGetCurrentTimeNs() + kTimeout2Ns;
460 RegisterAndValidateRequestForTimeout(request, kTimeout2Ns,
461 kShouldTimeout2AtNs);
462
463 std::this_thread::sleep_for(
464 std::chrono::nanoseconds(kShouldTimeout1AtNs - chppGetCurrentTimeNs()) +
465 kTimeoutPadding);
466 // First request would have timed out but superseded by second request.
467 EXPECT_GT(GetNextRequestTimeoutNs(), chppGetCurrentTimeNs());
468
469 std::this_thread::sleep_for(
470 std::chrono::nanoseconds(kShouldTimeout2AtNs - chppGetCurrentTimeNs()) +
471 kTimeoutPadding);
472 // Second request should have timed out - so we get a response.
473 EXPECT_LT(GetNextRequestTimeoutNs(), chppGetCurrentTimeNs());
474
475 struct ChppAppHeader *response = GetTimeoutResponse();
476 ASSERT_NE(response, nullptr);
477 validateTimeoutResponse(request, response);
478 chppFree(response);
479
480 RegisterAndValidateResponseForTimeout(request, CHPP_TIME_MAX);
481 EXPECT_EQ(GetTimeoutResponse(), nullptr);
482
483 chppFree(request);
484 }
485
TEST_P(TimeoutParamTest,RequestTimeoutResponse)486 TEST_P(TimeoutParamTest, RequestTimeoutResponse) {
487 EXPECT_EQ(GetNextRequestTimeoutNs(), CHPP_TIME_MAX);
488
489 struct ChppAppHeader *request1 = AllocRequestCommand(1 /* command */);
490 struct ChppAppHeader *request2 = AllocRequestCommand(2 /* command */);
491 ASSERT_NE(request1, nullptr);
492 ASSERT_NE(request2, nullptr);
493
494 const uint64_t time1Ns = chppGetCurrentTimeNs();
495 constexpr uint64_t kTimeout1Ns = 200 * CHPP_NSEC_PER_MSEC;
496 RegisterAndValidateRequestForTimeout(request1, kTimeout1Ns,
497 time1Ns + kTimeout1Ns);
498
499 std::this_thread::sleep_for(std::chrono::nanoseconds(kTimeout1Ns));
500 ASSERT_LT(GetNextRequestTimeoutNs(), chppGetCurrentTimeNs());
501
502 // No response in time, we then get a timeout response.
503 struct ChppAppHeader *response = GetTimeoutResponse();
504 validateTimeoutResponse(request1, response);
505 chppFree(response);
506
507 RegisterAndValidateResponseForTimeout(request1, CHPP_TIME_MAX);
508 // No other request in timeout.
509 EXPECT_EQ(GetTimeoutResponse(), nullptr);
510
511 // Simulate a new timeout and make sure we have a timeout response.
512 const uint64_t time2Ns = chppGetCurrentTimeNs();
513 constexpr uint64_t kTimeout2Ns = 200 * CHPP_NSEC_PER_MSEC;
514 RegisterAndValidateRequestForTimeout(request2, kTimeout2Ns,
515 time2Ns + kTimeout2Ns);
516
517 std::this_thread::sleep_for(std::chrono::nanoseconds(kTimeout2Ns));
518 ASSERT_LT(GetNextRequestTimeoutNs(), chppGetCurrentTimeNs());
519
520 response = GetTimeoutResponse();
521 validateTimeoutResponse(request2, response);
522 chppFree(response);
523
524 chppFree(request1);
525 chppFree(request2);
526 }
527
528 INSTANTIATE_TEST_SUITE_P(
529 TimeoutTest, TimeoutParamTest,
530 testing::Values(CHPP_MESSAGE_TYPE_CLIENT_REQUEST,
531 CHPP_MESSAGE_TYPE_SERVICE_REQUEST),
__anon37ed931a0202(const testing::TestParamInfo<TimeoutParamTest::ParamType> &info) 532 [](const testing::TestParamInfo<TimeoutParamTest::ParamType> &info) {
533 return info.param == CHPP_MESSAGE_TYPE_CLIENT_REQUEST ? "ClientRequests"
534 : "ServiceRequests";
535 });
536
537 } // namespace
538 } // namespace chre