1 /*
2 * Copyright 2024 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 #define LOG_TAG "SharedSessionConfigUtilsTest"
18
19 #include <android/hardware_buffer.h>
20 #include <camera/camera2/OutputConfiguration.h>
21 #include <system/camera_metadata.h>
22 #include <system/graphics.h>
23
24 #include <gtest/gtest.h>
25 #include "../config/SharedSessionConfigUtils.h"
26 #include <tinyxml2.h>
27
28 using namespace android;
29 using namespace tinyxml2;
30
31 // Helper function to create an XML element with text
CreateXMLElement(XMLDocument & doc,const char * elementName,const char * text)32 XMLElement* CreateXMLElement(XMLDocument& doc, const char* elementName, const char* text) {
33 XMLElement* elem = doc.NewElement(elementName);
34 if (text != nullptr) {
35 elem->SetText(text);
36 }
37 doc.InsertEndChild(elem);
38 return elem;
39 }
40
41 // Test for SharedSessionConfigUtils::toString
TEST(SharedSessionConfigUtilsTest,ToStringTest)42 TEST(SharedSessionConfigUtilsTest, ToStringTest) {
43 EXPECT_STREQ(SharedSessionConfigUtils::toString(ErrorCode::STATUS_OK), "STATUS_OK");
44 EXPECT_STREQ(SharedSessionConfigUtils::toString(ErrorCode::ERROR_READ_CONFIG_FILE),
45 "ERROR_READ_CONFIG_FILE");
46 EXPECT_STREQ(SharedSessionConfigUtils::toString(ErrorCode::ERROR_CONFIG_FILE_FORMAT),
47 "ERROR_CONFIG_FILE_FORMAT");
48 EXPECT_STREQ(SharedSessionConfigUtils::toString(
49 ErrorCode::ERROR_CONFIG_READER_UNINITIALIZED),
50 "ERROR_CONFIG_READER_UNINITIALIZED");
51 EXPECT_STREQ(SharedSessionConfigUtils::toString(ErrorCode::ERROR_BAD_PARAMETER),
52 "ERROR_BAD_PARAMETER");
53
54 // Test default case (unknown ErrorCode)
55 EXPECT_STREQ(SharedSessionConfigUtils::toString(static_cast<ErrorCode>(999)), "");
56 }
57
58 // Test for SharedSessionConfigUtils::getColorSpaceFromStr
TEST(SharedSessionConfigUtilsTest,GetColorSpaceFromStrTest)59 TEST(SharedSessionConfigUtilsTest, GetColorSpaceFromStrTest) {
60 int32_t colorSpace;
61 // Test with nullptr
62 EXPECT_EQ(SharedSessionConfigUtils::getColorSpaceFromStr(nullptr, &colorSpace),
63 ErrorCode::STATUS_OK);
64 EXPECT_EQ(colorSpace, ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED);
65
66 // Test with empty string
67 EXPECT_EQ(SharedSessionConfigUtils::getColorSpaceFromStr("", &colorSpace),
68 ErrorCode::STATUS_OK);
69 EXPECT_EQ(colorSpace, ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED);
70
71 // Test with valid strings
72 struct {
73 std::string input;
74 int expected;
75 } testCases[] = {
76 {std::to_string(ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED),
77 ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED},
78 {std::to_string(ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_SRGB),
79 ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_SRGB},
80 {std::to_string(ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_DISPLAY_P3),
81 ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_DISPLAY_P3},
82 {std::to_string(ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_BT2020_HLG),
83 ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_BT2020_HLG}
84 };
85
86 for (const auto& testCase : testCases) {
87 EXPECT_EQ(SharedSessionConfigUtils::getColorSpaceFromStr(testCase.input.c_str(),
88 &colorSpace),
89 ErrorCode::STATUS_OK);
90 EXPECT_EQ(colorSpace, testCase.expected);
91 }
92
93 // Test with invalid string
94 EXPECT_EQ(SharedSessionConfigUtils::getColorSpaceFromStr("-99", &colorSpace),
95 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
96 }
97
98 // Test for SharedSessionConfigUtils::getSurfaceTypeFromXml
TEST(SharedSessionConfigUtilsTest,GetSurfaceTypeFromXmlTest)99 TEST(SharedSessionConfigUtilsTest, GetSurfaceTypeFromXmlTest) {
100 int64_t surfaceType;
101
102 // Test with nullptr XML element
103 EXPECT_EQ(SharedSessionConfigUtils::getSurfaceTypeFromXml(nullptr, &surfaceType),
104 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
105
106 // Test with empty text
107 XMLDocument doc;
108 XMLElement* emptyElem = CreateXMLElement(doc, "surfaceType", "");
109 EXPECT_EQ(SharedSessionConfigUtils::getSurfaceTypeFromXml(emptyElem, &surfaceType),
110 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
111
112 // Test with valid surface types
113 struct {
114 std::string input;
115 int expected;
116 } testCases[] = {
117 {std::to_string(OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW),
118 OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW},
119 {std::to_string(OutputConfiguration::SURFACE_TYPE_SURFACE_TEXTURE),
120 OutputConfiguration::SURFACE_TYPE_SURFACE_TEXTURE},
121 {std::to_string(OutputConfiguration::SURFACE_TYPE_MEDIA_RECORDER),
122 OutputConfiguration::SURFACE_TYPE_MEDIA_RECORDER},
123 {std::to_string(OutputConfiguration::SURFACE_TYPE_MEDIA_CODEC),
124 OutputConfiguration::SURFACE_TYPE_MEDIA_CODEC},
125 {std::to_string(OutputConfiguration::SURFACE_TYPE_IMAGE_READER),
126 OutputConfiguration::SURFACE_TYPE_IMAGE_READER}
127 };
128
129 for (const auto& testCase : testCases) {
130 XMLElement* elem = CreateXMLElement(doc, "surfaceType", testCase.input.c_str());
131 EXPECT_EQ(SharedSessionConfigUtils::getSurfaceTypeFromXml(elem, &surfaceType),
132 ErrorCode::STATUS_OK);
133 EXPECT_EQ(surfaceType, testCase.expected);
134 }
135
136 // Test with invalid surface type
137 XMLElement* invalidElem = CreateXMLElement(doc, "surfaceType", "-99");
138 EXPECT_EQ(SharedSessionConfigUtils::getSurfaceTypeFromXml(invalidElem, &surfaceType),
139 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
140 }
141
142 // Test for SharedSessionConfigUtils::getWidthFromXml
TEST(SharedSessionConfigUtilsTest,GetWidthFromXmlTest)143 TEST(SharedSessionConfigUtilsTest, GetWidthFromXmlTest) {
144 int64_t width;
145
146 // Test with nullptr XML element
147 EXPECT_EQ(SharedSessionConfigUtils::getWidthFromXml(nullptr, &width),
148 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
149
150 XMLDocument doc;
151 // Test with empty text
152 XMLElement* emptyElem = CreateXMLElement(doc, "width", "");
153 EXPECT_EQ(SharedSessionConfigUtils::getWidthFromXml(emptyElem, &width),
154 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
155
156 // Test with valid width
157 XMLElement* validElem = CreateXMLElement(doc, "width", "1920");
158 EXPECT_EQ(SharedSessionConfigUtils::getWidthFromXml(validElem, &width),
159 ErrorCode::STATUS_OK);
160 EXPECT_EQ(width, 1920);
161
162 // Test with invalid width (negative)
163 XMLElement* invalidWidthElem = CreateXMLElement(doc, "width", "-100");
164 EXPECT_EQ(SharedSessionConfigUtils::getWidthFromXml(invalidWidthElem, &width),
165 ErrorCode::STATUS_OK);
166 EXPECT_EQ(width, -100); // The method logs an error but still returns STATUS_OK
167
168 // Test with non-numeric width
169 XMLElement* nonNumericElem = CreateXMLElement(doc, "width", "abc");
170 EXPECT_EQ(SharedSessionConfigUtils::getWidthFromXml(nonNumericElem, &width),
171 ErrorCode::STATUS_OK);
172 EXPECT_EQ(width, 0); // std::atoi returns 0 for non-numeric strings
173 }
174
175 // Test for SharedSessionConfigUtils::getHeightFromXml
TEST(SharedSessionConfigUtilsTest,GetHeightFromXmlTest)176 TEST(SharedSessionConfigUtilsTest, GetHeightFromXmlTest) {
177 int64_t height;
178
179 XMLDocument doc;
180 // Test with nullptr XML element
181 EXPECT_EQ(SharedSessionConfigUtils::getHeightFromXml(nullptr, &height),
182 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
183
184 // Test with empty text
185 XMLElement* emptyElem = CreateXMLElement(doc, "height", "");
186 EXPECT_EQ(SharedSessionConfigUtils::getHeightFromXml(emptyElem, &height),
187 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
188
189 // Test with valid height
190 XMLElement* validElem = CreateXMLElement(doc, "height", "1080");
191 EXPECT_EQ(SharedSessionConfigUtils::getHeightFromXml(validElem, &height), ErrorCode::STATUS_OK);
192 EXPECT_EQ(height, 1080);
193
194 // Test with invalid height (zero)
195 XMLElement* invalidHeightElem = CreateXMLElement(doc, "height", "0");
196 EXPECT_EQ(SharedSessionConfigUtils::getHeightFromXml(invalidHeightElem, &height),
197 ErrorCode::STATUS_OK);
198 EXPECT_EQ(height, 0); // The method logs an error but still returns STATUS_OK
199
200 // Test with non-numeric height
201 XMLElement* nonNumericElem = CreateXMLElement(doc, "height", "xyz");
202 EXPECT_EQ(SharedSessionConfigUtils::getHeightFromXml(nonNumericElem, &height),
203 ErrorCode::STATUS_OK);
204 EXPECT_EQ(height, 0); // std::atoi returns 0 for non-numeric strings
205 }
206
207 // Test for SharedSessionConfigUtils::getPhysicalCameraIdFromXml
TEST(SharedSessionConfigUtilsTest,GetPhysicalCameraIdFromXmlTest)208 TEST(SharedSessionConfigUtilsTest, GetPhysicalCameraIdFromXmlTest) {
209 std::string physicalCameraId;
210
211 // Test with nullptr XML element
212 EXPECT_EQ(SharedSessionConfigUtils::getPhysicalCameraIdFromXml(nullptr, &physicalCameraId),
213 ErrorCode::STATUS_OK);
214 EXPECT_EQ(physicalCameraId, "");
215
216 XMLDocument doc;
217 // Test with empty text
218 XMLElement* emptyElem = CreateXMLElement(doc, "physicalCameraId", "");
219 EXPECT_EQ(SharedSessionConfigUtils::getPhysicalCameraIdFromXml(emptyElem, &physicalCameraId),
220 ErrorCode::STATUS_OK);
221 EXPECT_EQ(physicalCameraId, "");
222
223 // Test with valid physical camera ID
224 XMLElement* validElem = CreateXMLElement(doc, "physicalCameraId", "physical_camera_1");
225 EXPECT_EQ(SharedSessionConfigUtils::getPhysicalCameraIdFromXml(validElem, &physicalCameraId),
226 ErrorCode::STATUS_OK);
227 EXPECT_EQ(physicalCameraId, "physical_camera_1");
228 }
229
230 // Test for SharedSessionConfigUtils::getStreamUseCaseFromXml
TEST(SharedSessionConfigUtilsTest,GetStreamUseCaseFromXmlTest)231 TEST(SharedSessionConfigUtilsTest, GetStreamUseCaseFromXmlTest) {
232 int64_t streamUseCase;
233
234 // Test with nullptr XML element
235 EXPECT_EQ(SharedSessionConfigUtils::getStreamUseCaseFromXml(nullptr, &streamUseCase),
236 ErrorCode::STATUS_OK);
237 EXPECT_EQ(streamUseCase, ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT);
238
239 XMLDocument doc;
240 // Test with empty text
241 XMLElement* emptyElem = CreateXMLElement(doc, "streamUseCase", "");
242 EXPECT_EQ(SharedSessionConfigUtils::getStreamUseCaseFromXml(emptyElem, &streamUseCase),
243 ErrorCode::STATUS_OK);
244 EXPECT_EQ(streamUseCase, ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT);
245
246 // Test with valid stream use cases
247 struct {
248 std::string input;
249 int64_t expected;
250 } testCases[] = {
251 {std::to_string(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT),
252 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT},
253 {std::to_string(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW),
254 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW},
255 {std::to_string(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE),
256 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE},
257 {std::to_string(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD),
258 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD},
259 {std::to_string(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL),
260 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL},
261 {std::to_string(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL),
262 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL},
263 {std::to_string(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW),
264 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW},
265 {std::to_string(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VENDOR_START),
266 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VENDOR_START}
267 };
268
269 for (const auto& testCase : testCases) {
270 XMLElement* elem = CreateXMLElement(doc, "streamUseCase", testCase.input.c_str());
271 EXPECT_EQ(SharedSessionConfigUtils::getStreamUseCaseFromXml(elem, &streamUseCase),
272 ErrorCode::STATUS_OK);
273 EXPECT_EQ(streamUseCase, testCase.expected);
274 }
275
276 // Test with invalid stream use case
277 XMLElement* invalidElem = CreateXMLElement(doc, "streamUseCase", "-99");
278 EXPECT_EQ(SharedSessionConfigUtils::getStreamUseCaseFromXml(invalidElem, &streamUseCase),
279 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
280 }
281
282 // Test for SharedSessionConfigUtils::getTimestampBaseFromXml
TEST(SharedSessionConfigUtilsTest,GetTimestampBaseFromXmlTest)283 TEST(SharedSessionConfigUtilsTest, GetTimestampBaseFromXmlTest) {
284 int64_t timestampBase;
285
286 // Test with nullptr XML element
287 EXPECT_EQ(SharedSessionConfigUtils::getTimestampBaseFromXml(nullptr, ×tampBase),
288 ErrorCode::STATUS_OK);
289 EXPECT_EQ(timestampBase, OutputConfiguration::TIMESTAMP_BASE_DEFAULT);
290
291 XMLDocument doc;
292 // Test with empty text
293 XMLElement* emptyElem = CreateXMLElement(doc, "timestampBase", "");
294 EXPECT_EQ(SharedSessionConfigUtils::getTimestampBaseFromXml(emptyElem, ×tampBase),
295 ErrorCode::STATUS_OK);
296 EXPECT_EQ(timestampBase, OutputConfiguration::TIMESTAMP_BASE_DEFAULT);
297
298 // Test with valid timestamp bases
299 struct {
300 std::string input;
301 int expected;
302 } testCases[] = {
303 {std::to_string(OutputConfiguration::TIMESTAMP_BASE_DEFAULT),
304 OutputConfiguration::TIMESTAMP_BASE_DEFAULT},
305 {std::to_string(OutputConfiguration::TIMESTAMP_BASE_SENSOR),
306 OutputConfiguration::TIMESTAMP_BASE_SENSOR},
307 {std::to_string(OutputConfiguration::TIMESTAMP_BASE_MONOTONIC),
308 OutputConfiguration::TIMESTAMP_BASE_MONOTONIC},
309 {std::to_string(OutputConfiguration::TIMESTAMP_BASE_REALTIME),
310 OutputConfiguration::TIMESTAMP_BASE_REALTIME},
311 {std::to_string(OutputConfiguration::TIMESTAMP_BASE_CHOREOGRAPHER_SYNCED),
312 OutputConfiguration::TIMESTAMP_BASE_CHOREOGRAPHER_SYNCED},
313 {std::to_string(OutputConfiguration::TIMESTAMP_BASE_MAX),
314 OutputConfiguration::TIMESTAMP_BASE_MAX}
315 };
316
317 for (const auto& testCase : testCases) {
318 XMLElement* elem = CreateXMLElement(doc, "timestampBase", testCase.input.c_str());
319 EXPECT_EQ(SharedSessionConfigUtils::getTimestampBaseFromXml(elem, ×tampBase),
320 ErrorCode::STATUS_OK);
321 EXPECT_EQ(timestampBase, testCase.expected);
322 }
323
324 // Test with invalid timestamp base
325 XMLElement* invalidElem = CreateXMLElement(doc, "timestampBase", "-99");
326 EXPECT_EQ(SharedSessionConfigUtils::getTimestampBaseFromXml(invalidElem, ×tampBase),
327 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
328 }
329
330 // Test for SharedSessionConfigUtils::getMirrorModeFromXml
TEST(SharedSessionConfigUtilsTest,GetMirrorModeFromXmlTest)331 TEST(SharedSessionConfigUtilsTest, GetMirrorModeFromXmlTest) {
332 int64_t mirrorMode;
333
334 // Test with nullptr XML element
335 EXPECT_EQ(SharedSessionConfigUtils::getMirrorModeFromXml(nullptr, &mirrorMode),
336 ErrorCode::STATUS_OK);
337 EXPECT_EQ(mirrorMode, OutputConfiguration::MIRROR_MODE_AUTO);
338
339 XMLDocument doc;
340 // Test with empty text
341 XMLElement* emptyElem = CreateXMLElement(doc, "mirrorMode", "");
342 EXPECT_EQ(SharedSessionConfigUtils::getMirrorModeFromXml(emptyElem, &mirrorMode),
343 ErrorCode::STATUS_OK);
344 EXPECT_EQ(mirrorMode, OutputConfiguration::MIRROR_MODE_AUTO);
345
346 // Test with valid mirror modes
347 struct {
348 std::string input;
349 int expected;
350 } testCases[] = {
351 {std::to_string(OutputConfiguration::MIRROR_MODE_AUTO),
352 OutputConfiguration::MIRROR_MODE_AUTO},
353 {std::to_string(OutputConfiguration::MIRROR_MODE_NONE),
354 OutputConfiguration::MIRROR_MODE_NONE},
355 {std::to_string(OutputConfiguration::MIRROR_MODE_H),
356 OutputConfiguration::MIRROR_MODE_H},
357 {std::to_string(OutputConfiguration::MIRROR_MODE_V),
358 OutputConfiguration::MIRROR_MODE_V}
359 };
360
361 for (const auto& testCase : testCases) {
362 XMLElement* elem = CreateXMLElement(doc, "mirrorMode", testCase.input.c_str());
363 EXPECT_EQ(SharedSessionConfigUtils::getMirrorModeFromXml(elem, &mirrorMode),
364 ErrorCode::STATUS_OK);
365 EXPECT_EQ(mirrorMode, testCase.expected);
366 }
367
368 // Test with invalid mirror mode
369 XMLElement* invalidElem = CreateXMLElement(doc, "mirrorMode", "-99");
370 EXPECT_EQ(SharedSessionConfigUtils::getMirrorModeFromXml(invalidElem, &mirrorMode),
371 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
372 }
373
374 // Test for SharedSessionConfigUtils::getUseReadoutTimestampFromXml
TEST(SharedSessionConfigUtilsTest,GetUseReadoutTimestampFromXmlTest)375 TEST(SharedSessionConfigUtilsTest, GetUseReadoutTimestampFromXmlTest) {
376 bool useReadoutTimestamp;
377
378 // Test with nullptr XML element
379 EXPECT_EQ(SharedSessionConfigUtils::getUseReadoutTimestampFromXml(nullptr,
380 &useReadoutTimestamp),
381 ErrorCode::STATUS_OK);
382 EXPECT_FALSE(useReadoutTimestamp);
383
384 XMLDocument doc;
385 // Test with empty text (should default to false)
386 XMLElement* emptyElem = CreateXMLElement(doc, "useReadoutTimestamp", "");
387 EXPECT_EQ(SharedSessionConfigUtils::getUseReadoutTimestampFromXml(emptyElem,
388 &useReadoutTimestamp),
389 ErrorCode::STATUS_OK);
390 EXPECT_FALSE(useReadoutTimestamp);
391
392 // Test with "true"
393 XMLElement* trueElem = CreateXMLElement(doc, "useReadoutTimestamp", "1");
394 EXPECT_EQ(SharedSessionConfigUtils::getUseReadoutTimestampFromXml(trueElem,
395 &useReadoutTimestamp),
396 ErrorCode::STATUS_OK);
397 EXPECT_TRUE(useReadoutTimestamp);
398
399 // Test with "false"
400 XMLElement* falseElem = CreateXMLElement(doc, "useReadoutTimestamp", "0");
401 EXPECT_EQ(SharedSessionConfigUtils::getUseReadoutTimestampFromXml(falseElem,
402 &useReadoutTimestamp),
403 ErrorCode::STATUS_OK);
404 EXPECT_FALSE(useReadoutTimestamp);
405
406 // Test with invalid string
407 XMLElement* invalidElem = CreateXMLElement(doc, "useReadoutTimestamp", "-99");
408 EXPECT_EQ(SharedSessionConfigUtils::getUseReadoutTimestampFromXml(invalidElem,
409 &useReadoutTimestamp),
410 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
411 }
412
413 // Test for SharedSessionConfigUtils::getFormatFromXml
TEST(SharedSessionConfigUtilsTest,GetFormatFromXmlTest)414 TEST(SharedSessionConfigUtilsTest, GetFormatFromXmlTest) {
415 int64_t format;
416
417 int64_t surfaceType = OutputConfiguration::SURFACE_TYPE_SURFACE_TEXTURE;
418 // Test with nullptr XML element with surfaceType != IMAGE_READER
419 EXPECT_EQ(SharedSessionConfigUtils::getFormatFromXml(nullptr, &format, surfaceType),
420 ErrorCode::STATUS_OK);
421 EXPECT_EQ(format, HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED);
422
423 surfaceType = OutputConfiguration::SURFACE_TYPE_IMAGE_READER;
424 // Test with nullptr XML element with surfaceType == IMAGE_READER
425 EXPECT_EQ(SharedSessionConfigUtils::getFormatFromXml(nullptr, &format, surfaceType),
426 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
427
428 XMLDocument doc;
429 // Test with empty text
430 XMLElement* emptyElem = CreateXMLElement(doc, "format", "");
431 EXPECT_EQ(SharedSessionConfigUtils::getFormatFromXml(emptyElem, &format, surfaceType),
432 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
433
434 // Test with valid formats
435 struct {
436 std::string input;
437 int expected;
438 } testCases[] = {
439 {std::to_string(HAL_PIXEL_FORMAT_RGBA_8888), HAL_PIXEL_FORMAT_RGBA_8888},
440 {std::to_string(HAL_PIXEL_FORMAT_RGBX_8888), HAL_PIXEL_FORMAT_RGBX_8888},
441 {std::to_string(HAL_PIXEL_FORMAT_RGB_888), HAL_PIXEL_FORMAT_RGB_888},
442 {std::to_string(HAL_PIXEL_FORMAT_RGB_565), HAL_PIXEL_FORMAT_RGB_565},
443 {std::to_string(HAL_PIXEL_FORMAT_BGRA_8888), HAL_PIXEL_FORMAT_BGRA_8888},
444 {std::to_string(HAL_PIXEL_FORMAT_YCBCR_422_SP), HAL_PIXEL_FORMAT_YCBCR_422_SP},
445 {std::to_string(HAL_PIXEL_FORMAT_YCRCB_420_SP), HAL_PIXEL_FORMAT_YCRCB_420_SP},
446 {std::to_string(HAL_PIXEL_FORMAT_YCBCR_422_I), HAL_PIXEL_FORMAT_YCBCR_422_I},
447 {std::to_string(HAL_PIXEL_FORMAT_RGBA_FP16), HAL_PIXEL_FORMAT_RGBA_FP16},
448 {std::to_string(HAL_PIXEL_FORMAT_RAW16), HAL_PIXEL_FORMAT_RAW16},
449 {std::to_string(HAL_PIXEL_FORMAT_BLOB), HAL_PIXEL_FORMAT_BLOB},
450 {std::to_string(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
451 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED},
452 {std::to_string(HAL_PIXEL_FORMAT_YCBCR_420_888), HAL_PIXEL_FORMAT_YCBCR_420_888},
453 {std::to_string(HAL_PIXEL_FORMAT_RAW_OPAQUE), HAL_PIXEL_FORMAT_RAW_OPAQUE},
454 {std::to_string(HAL_PIXEL_FORMAT_RAW10), HAL_PIXEL_FORMAT_RAW10},
455 {std::to_string(HAL_PIXEL_FORMAT_RAW12), HAL_PIXEL_FORMAT_RAW12},
456 {std::to_string(HAL_PIXEL_FORMAT_RGBA_1010102), HAL_PIXEL_FORMAT_RGBA_1010102},
457 {std::to_string(HAL_PIXEL_FORMAT_Y8), HAL_PIXEL_FORMAT_Y8},
458 {std::to_string(HAL_PIXEL_FORMAT_Y16), HAL_PIXEL_FORMAT_Y16},
459 {std::to_string(HAL_PIXEL_FORMAT_YV12), HAL_PIXEL_FORMAT_YV12},
460 {std::to_string(HAL_PIXEL_FORMAT_DEPTH_16), HAL_PIXEL_FORMAT_DEPTH_16},
461 {std::to_string(HAL_PIXEL_FORMAT_DEPTH_24), HAL_PIXEL_FORMAT_DEPTH_24},
462 {std::to_string(HAL_PIXEL_FORMAT_DEPTH_24_STENCIL_8),
463 HAL_PIXEL_FORMAT_DEPTH_24_STENCIL_8},
464 {std::to_string(HAL_PIXEL_FORMAT_DEPTH_32F), HAL_PIXEL_FORMAT_DEPTH_32F},
465 {std::to_string(HAL_PIXEL_FORMAT_DEPTH_32F_STENCIL_8),
466 HAL_PIXEL_FORMAT_DEPTH_32F_STENCIL_8},
467 {std::to_string(HAL_PIXEL_FORMAT_STENCIL_8), HAL_PIXEL_FORMAT_STENCIL_8},
468 {std::to_string(HAL_PIXEL_FORMAT_YCBCR_P010), HAL_PIXEL_FORMAT_YCBCR_P010},
469 {std::to_string(HAL_PIXEL_FORMAT_HSV_888), HAL_PIXEL_FORMAT_HSV_888}
470 };
471
472 for (const auto& testCase : testCases) {
473 XMLElement* elem = CreateXMLElement(doc, "format", testCase.input.c_str());
474 EXPECT_EQ(SharedSessionConfigUtils::getFormatFromXml(elem, &format, surfaceType),
475 ErrorCode::STATUS_OK);
476 EXPECT_EQ(format, testCase.expected);
477 }
478
479 // Test with invalid format
480 XMLElement* invalidElem = CreateXMLElement(doc, "format", "-99");
481 EXPECT_EQ(SharedSessionConfigUtils::getFormatFromXml(invalidElem, &format, surfaceType),
482 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
483 }
484
485 // Test for SharedSessionConfigUtils::getUsageFromXml
TEST(SharedSessionConfigUtilsTest,GetUsageFromXmlTest)486 TEST(SharedSessionConfigUtilsTest, GetUsageFromXmlTest) {
487 int64_t usage = 0;
488
489 int64_t surfaceType = OutputConfiguration::SURFACE_TYPE_SURFACE_TEXTURE;
490 // Test with nullptr XML element with surfaceType == SURFACE_TYPE_SURFACE_TEXTURE
491 EXPECT_EQ(SharedSessionConfigUtils::getUsageFromXml(nullptr, &usage, surfaceType),
492 ErrorCode::STATUS_OK);
493 EXPECT_EQ(usage, static_cast<int64_t>(AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE));
494
495 // clear usage value
496 usage = 0;
497 surfaceType = OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW;
498 // Test with nullptr XML element with surfaceType == SURFACE_TYPE_SURFACE_VIEW
499 EXPECT_EQ(SharedSessionConfigUtils::getUsageFromXml(nullptr, &usage, surfaceType),
500 ErrorCode::STATUS_OK);
501 EXPECT_EQ(usage, static_cast<int64_t>(AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE
502 | AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY));
503
504 // clear usage value
505 usage = 0;
506 surfaceType = OutputConfiguration::SURFACE_TYPE_MEDIA_RECORDER;
507 // Test with nullptr XML element with surfaceType == SURFACE_TYPE_MEDIA_RECORDER
508 EXPECT_EQ(SharedSessionConfigUtils::getUsageFromXml(nullptr, &usage, surfaceType),
509 ErrorCode::STATUS_OK);
510 EXPECT_EQ(usage, static_cast<int64_t>(AHARDWAREBUFFER_USAGE_VIDEO_ENCODE));
511
512 // clear usage value
513 usage = 0;
514 surfaceType = OutputConfiguration::SURFACE_TYPE_MEDIA_CODEC;
515 // Test with nullptr XML element with surfaceType == SURFACE_TYPE_MEDIA_CODEC
516 EXPECT_EQ(SharedSessionConfigUtils::getUsageFromXml(nullptr, &usage, surfaceType),
517 ErrorCode::STATUS_OK);
518 EXPECT_EQ(usage, static_cast<int64_t>(AHARDWAREBUFFER_USAGE_VIDEO_ENCODE));
519
520 // clear usage value
521 usage = 0;
522 surfaceType = OutputConfiguration::SURFACE_TYPE_IMAGE_READER;
523 // Test with nullptr XML element with surfaceType == IMAGE_READER
524 EXPECT_EQ(SharedSessionConfigUtils::getUsageFromXml(nullptr, &usage, surfaceType),
525 ErrorCode::STATUS_OK);
526 EXPECT_EQ(usage, static_cast<int64_t>(AHARDWAREBUFFER_USAGE_CPU_READ_NEVER));
527
528
529 // clear usage value
530 usage = 0;
531 XMLDocument doc;
532 // Test with empty text
533 XMLElement* emptyElem = CreateXMLElement(doc, "usage", "");
534 EXPECT_EQ(SharedSessionConfigUtils::getUsageFromXml(emptyElem, &usage, surfaceType),
535 ErrorCode::STATUS_OK);
536 EXPECT_EQ(usage, static_cast<int64_t>(AHARDWAREBUFFER_USAGE_CPU_READ_NEVER));
537
538 // clear usage value
539 usage = 0;
540 // Test with valid single usage
541 XMLElement* singleUsageElem = CreateXMLElement(doc, "usage",
542 std::to_string(
543 AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN)
544 .c_str());
545 EXPECT_EQ(SharedSessionConfigUtils::getUsageFromXml(singleUsageElem, &usage, surfaceType),
546 ErrorCode::STATUS_OK);
547 EXPECT_EQ(usage, static_cast<int64_t>(AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN));
548
549 // clear usage value
550 usage = 0;
551 // Test with valid multiple usages
552 XMLElement* multipleUsagesElem =
553 CreateXMLElement(doc, "usage",
554 (std::to_string(AHARDWAREBUFFER_USAGE_CPU_READ_NEVER)
555 + "|" + std::to_string(AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER)
556 + "|" + std::to_string(AHARDWAREBUFFER_USAGE_VIDEO_ENCODE))
557 .c_str());
558 EXPECT_EQ(SharedSessionConfigUtils::getUsageFromXml(multipleUsagesElem, &usage, surfaceType),
559 ErrorCode::STATUS_OK);
560 EXPECT_EQ(usage, static_cast<int64_t>(AHARDWAREBUFFER_USAGE_CPU_READ_NEVER
561 | AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER
562 | AHARDWAREBUFFER_USAGE_VIDEO_ENCODE));
563
564 // clear usage value
565 usage = 0;
566 // Test with invalid usage
567 XMLElement* invalidUsageElem = CreateXMLElement(doc, "usage", "-99");
568 EXPECT_EQ(SharedSessionConfigUtils::getUsageFromXml(invalidUsageElem, &usage, surfaceType),
569 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
570
571 // clear usage value
572 usage = 0;
573 // Test with a mix of valid and invalid usages
574 XMLElement* mixedUsageElem =
575 CreateXMLElement(doc, "usage",
576 (std::to_string(AHARDWAREBUFFER_USAGE_CPU_READ_NEVER) + "|-99")
577 .c_str());
578 EXPECT_EQ(SharedSessionConfigUtils::getUsageFromXml(mixedUsageElem, &usage, surfaceType),
579 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
580 }
581
582 // Test for SharedSessionConfigUtils::getDataSpaceFromXml
TEST(SharedSessionConfigUtilsTest,GetDataSpaceFromXmlTest)583 TEST(SharedSessionConfigUtilsTest, GetDataSpaceFromXmlTest) {
584 int64_t dataSpace;
585
586 XMLDocument doc;
587 // Test with nullptr XML element
588 EXPECT_EQ(SharedSessionConfigUtils::getDataSpaceFromXml(nullptr, &dataSpace),
589 ErrorCode::STATUS_OK);
590 EXPECT_EQ(dataSpace, HAL_DATASPACE_UNKNOWN);
591
592 // Test with empty text
593 XMLElement* emptyElem = CreateXMLElement(doc, "dataSpace", "");
594 EXPECT_EQ(SharedSessionConfigUtils::getDataSpaceFromXml(emptyElem, &dataSpace),
595 ErrorCode::STATUS_OK);
596 EXPECT_EQ(dataSpace, HAL_DATASPACE_UNKNOWN);
597
598 // Test with valid data spaces
599 struct {
600 std::string input;
601 int expected;
602 } testCases[] = {
603 {std::to_string(HAL_DATASPACE_UNKNOWN), HAL_DATASPACE_UNKNOWN},
604 {std::to_string(HAL_DATASPACE_ARBITRARY), HAL_DATASPACE_ARBITRARY},
605 {std::to_string(HAL_DATASPACE_STANDARD_UNSPECIFIED),
606 HAL_DATASPACE_STANDARD_UNSPECIFIED},
607 {std::to_string(HAL_DATASPACE_STANDARD_BT709), HAL_DATASPACE_STANDARD_BT709},
608 {std::to_string(HAL_DATASPACE_STANDARD_BT601_625), HAL_DATASPACE_STANDARD_BT601_625},
609 {std::to_string(HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED),
610 HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED},
611 {std::to_string(HAL_DATASPACE_STANDARD_BT601_525), HAL_DATASPACE_STANDARD_BT601_525},
612 {std::to_string(HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED),
613 HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED},
614 {std::to_string(HAL_DATASPACE_STANDARD_BT2020), HAL_DATASPACE_STANDARD_BT2020},
615 {std::to_string(HAL_DATASPACE_STANDARD_BT2020_CONSTANT_LUMINANCE),
616 HAL_DATASPACE_STANDARD_BT2020_CONSTANT_LUMINANCE},
617 {std::to_string(HAL_DATASPACE_STANDARD_BT470M), HAL_DATASPACE_STANDARD_BT470M},
618 {std::to_string(HAL_DATASPACE_STANDARD_FILM), HAL_DATASPACE_STANDARD_FILM},
619 {std::to_string(HAL_DATASPACE_STANDARD_DCI_P3), HAL_DATASPACE_STANDARD_DCI_P3},
620 {std::to_string(HAL_DATASPACE_STANDARD_ADOBE_RGB), HAL_DATASPACE_STANDARD_ADOBE_RGB},
621 {std::to_string(HAL_DATASPACE_TRANSFER_UNSPECIFIED),
622 HAL_DATASPACE_TRANSFER_UNSPECIFIED},
623 {std::to_string(HAL_DATASPACE_TRANSFER_LINEAR), HAL_DATASPACE_TRANSFER_LINEAR},
624 {std::to_string(HAL_DATASPACE_TRANSFER_SRGB), HAL_DATASPACE_TRANSFER_SRGB},
625 {std::to_string(HAL_DATASPACE_TRANSFER_SMPTE_170M), HAL_DATASPACE_TRANSFER_SMPTE_170M},
626 {std::to_string(HAL_DATASPACE_TRANSFER_GAMMA2_2), HAL_DATASPACE_TRANSFER_GAMMA2_2},
627 {std::to_string(HAL_DATASPACE_TRANSFER_GAMMA2_6), HAL_DATASPACE_TRANSFER_GAMMA2_6},
628 {std::to_string(HAL_DATASPACE_TRANSFER_GAMMA2_8), HAL_DATASPACE_TRANSFER_GAMMA2_8},
629 {std::to_string(HAL_DATASPACE_TRANSFER_ST2084), HAL_DATASPACE_TRANSFER_ST2084},
630 {std::to_string(HAL_DATASPACE_TRANSFER_HLG), HAL_DATASPACE_TRANSFER_HLG},
631 {std::to_string(HAL_DATASPACE_RANGE_UNSPECIFIED), HAL_DATASPACE_RANGE_UNSPECIFIED},
632 {std::to_string(HAL_DATASPACE_RANGE_FULL), HAL_DATASPACE_RANGE_FULL},
633 {std::to_string(HAL_DATASPACE_RANGE_LIMITED), HAL_DATASPACE_RANGE_LIMITED},
634 {std::to_string(HAL_DATASPACE_RANGE_EXTENDED), HAL_DATASPACE_RANGE_EXTENDED},
635 {std::to_string(HAL_DATASPACE_SRGB_LINEAR), HAL_DATASPACE_SRGB_LINEAR},
636 {std::to_string(HAL_DATASPACE_V0_SRGB_LINEAR), HAL_DATASPACE_V0_SRGB_LINEAR},
637 {std::to_string(HAL_DATASPACE_V0_SCRGB_LINEAR), HAL_DATASPACE_V0_SCRGB_LINEAR},
638 {std::to_string(HAL_DATASPACE_SRGB), HAL_DATASPACE_SRGB},
639 {std::to_string(HAL_DATASPACE_V0_SRGB), HAL_DATASPACE_V0_SRGB},
640 {std::to_string(HAL_DATASPACE_V0_SCRGB), HAL_DATASPACE_V0_SCRGB},
641 {std::to_string(HAL_DATASPACE_JFIF), HAL_DATASPACE_JFIF},
642 {std::to_string(HAL_DATASPACE_V0_JFIF), HAL_DATASPACE_V0_JFIF},
643 {std::to_string(HAL_DATASPACE_BT601_625), HAL_DATASPACE_BT601_625},
644 {std::to_string(HAL_DATASPACE_V0_BT601_625), HAL_DATASPACE_V0_BT601_625},
645 {std::to_string(HAL_DATASPACE_BT601_525), HAL_DATASPACE_BT601_525},
646 {std::to_string(HAL_DATASPACE_V0_BT601_525), HAL_DATASPACE_V0_BT601_525},
647 {std::to_string(HAL_DATASPACE_BT709), HAL_DATASPACE_BT709},
648 {std::to_string(HAL_DATASPACE_V0_BT709), HAL_DATASPACE_V0_BT709},
649 {std::to_string(HAL_DATASPACE_DCI_P3_LINEAR), HAL_DATASPACE_DCI_P3_LINEAR},
650 {std::to_string(HAL_DATASPACE_DCI_P3), HAL_DATASPACE_DCI_P3},
651 {std::to_string(HAL_DATASPACE_DISPLAY_P3_LINEAR), HAL_DATASPACE_DISPLAY_P3_LINEAR},
652 {std::to_string(HAL_DATASPACE_DISPLAY_P3), HAL_DATASPACE_DISPLAY_P3},
653 {std::to_string(HAL_DATASPACE_ADOBE_RGB), HAL_DATASPACE_ADOBE_RGB},
654 {std::to_string(HAL_DATASPACE_BT2020_LINEAR), HAL_DATASPACE_BT2020_LINEAR},
655 {std::to_string(HAL_DATASPACE_BT2020), HAL_DATASPACE_BT2020},
656 {std::to_string(HAL_DATASPACE_BT2020_PQ), HAL_DATASPACE_BT2020_PQ},
657 {std::to_string(HAL_DATASPACE_DEPTH), HAL_DATASPACE_DEPTH},
658 {std::to_string(HAL_DATASPACE_SENSOR), HAL_DATASPACE_SENSOR}
659 };
660
661 for (const auto& testCase : testCases) {
662 XMLElement* elem = CreateXMLElement(doc, "dataSpace", testCase.input.c_str());
663 EXPECT_EQ(SharedSessionConfigUtils::getDataSpaceFromXml(elem, &dataSpace),
664 ErrorCode::STATUS_OK);
665 EXPECT_EQ(dataSpace, testCase.expected);
666 }
667
668 // Test with invalid data space
669 XMLElement* invalidElem = CreateXMLElement(doc, "dataSpace", "-99");
670 EXPECT_EQ(SharedSessionConfigUtils::getDataSpaceFromXml(invalidElem, &dataSpace),
671 ErrorCode::ERROR_CONFIG_FILE_FORMAT);
672 }
673