1 /*
2 * Copyright (C) 2023 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 <gtest/gtest.h>
18 #include <cstddef>
19 #include <cstdint>
20 #include <cstring>
21 #include <limits>
22 #include <locale>
23
24 #define LOG_TAG "EffectParamWrapper_Test"
25 #include <log/log.h>
26 #include <system/audio_effects/audio_effects_utils.h>
27
28 using namespace android;
29 using android::effect::utils::EffectParamReader;
30 using android::effect::utils::EffectParamWrapper;
31 using android::effect::utils::EffectParamWriter;
32 using android::effect::utils::operator==;
33 using android::effect::utils::operator!=;
34 using android::effect::utils::ToString;
35
TEST(EffectParamWrapperTest,setAndGetMatches)36 TEST(EffectParamWrapperTest, setAndGetMatches) {
37 effect_param_t param = {.psize = 2, .vsize = 0x10};
38 const auto wrapper = EffectParamWrapper(param);
39 effect_param_t target = wrapper.getEffectParam();
40 const auto targetWrapper = EffectParamWrapper(target);
41 EXPECT_TRUE(0 == std::memcmp(¶m, &target, sizeof(effect_param_t)));
42 EXPECT_EQ(targetWrapper, wrapper);
43 }
44
TEST(EffectParamWrapperTest,validateCmdSize)45 TEST(EffectParamWrapperTest, validateCmdSize) {
46 effect_param_t param = {.psize = 1, .vsize = 4};
47 const auto wrapper = EffectParamWrapper(param);
48 size_t minCmdSize = sizeof(effect_param_t) +
49 wrapper.getPaddedParameterSize() +
50 wrapper.getValueSize();
51 EXPECT_FALSE(wrapper.validateCmdSize(minCmdSize - 1));
52 EXPECT_TRUE(wrapper.validateCmdSize(minCmdSize));
53 EXPECT_TRUE(wrapper.validateCmdSize(minCmdSize + 1));
54 }
55
TEST(EffectParamWrapperTest,validateCmdSizeOverflow)56 TEST(EffectParamWrapperTest, validateCmdSizeOverflow) {
57 effect_param_t param = {.psize = std::numeric_limits<uint32_t>::max(),
58 .vsize = std::numeric_limits<uint32_t>::max()};
59 const auto wrapper = EffectParamWrapper(param);
60 uint64_t minCmdSize = (uint64_t)sizeof(effect_param_t) +
61 wrapper.getPaddedParameterSize() +
62 wrapper.getValueSize();
63 EXPECT_FALSE(wrapper.validateCmdSize(minCmdSize - 1));
64 EXPECT_TRUE(wrapper.validateCmdSize(minCmdSize));
65 EXPECT_TRUE(wrapper.validateCmdSize(minCmdSize + 1));
66 }
67
TEST(EffectParamWrapperTest,validateParamValueSize)68 TEST(EffectParamWrapperTest, validateParamValueSize) {
69 effect_param_t param = {.psize = 1, .vsize = 4};
70 const auto wrapper = EffectParamWrapper(param);
71 EXPECT_TRUE(wrapper.validateParamValueSize(param.psize, param.vsize));
72 EXPECT_TRUE(wrapper.validateParamValueSize(0, param.vsize));
73 EXPECT_TRUE(wrapper.validateParamValueSize(param.psize, 0));
74 EXPECT_FALSE(wrapper.validateParamValueSize(param.psize + 1, 0));
75 EXPECT_FALSE(wrapper.validateParamValueSize(0, param.vsize + 1));
76 }
77
TEST(EffectParamWrapperTest,padding)78 TEST(EffectParamWrapperTest, padding) {
79 for (size_t i = 0; i < 0x100; i++) {
80 EXPECT_EQ(
81 sizeof(uint32_t) * ((i + sizeof(uint32_t) - 1) / sizeof(uint32_t)),
82 EffectParamWrapper::padding(i))
83 << i;
84 }
85 }
86
TEST(EffectParamWrapperTest,getPaddedParameterSize)87 TEST(EffectParamWrapperTest, getPaddedParameterSize) {
88 effect_param_t psize1 = {.psize = 1};
89 const auto wrapper1 = EffectParamWrapper(psize1);
90 EXPECT_EQ(4, wrapper1.getPaddedParameterSize());
91 EXPECT_EQ(4, wrapper1.padding(psize1.psize));
92
93 effect_param_t psize4 = {.psize = 4};
94 const auto wrapper4 = EffectParamWrapper(psize4);
95 EXPECT_EQ(4, wrapper4.getPaddedParameterSize());
96 EXPECT_EQ(wrapper4.getPaddedParameterSize(), wrapper4.padding(psize4.psize));
97
98 effect_param_t psize6 = {.psize = 6};
99 const auto wrapper6 = EffectParamWrapper(psize6);
100 EXPECT_EQ(8, wrapper6.getPaddedParameterSize());
101 EXPECT_EQ(wrapper6.getPaddedParameterSize(), wrapper6.padding(psize6.psize));
102 }
103
TEST(EffectParamWrapperTest,getPVSize)104 TEST(EffectParamWrapperTest, getPVSize) {
105 effect_param_t vsize1 = {.psize = 0xff, .vsize = 1};
106 const auto wrapper1 = EffectParamWrapper(vsize1);
107 EXPECT_EQ(vsize1.vsize, wrapper1.getValueSize());
108
109 effect_param_t vsize2 = {.psize = 0xbe, .vsize = 0xff};
110 const auto wrapper2 = EffectParamWrapper(vsize2);
111 EXPECT_EQ(vsize2.vsize, wrapper2.getValueSize());
112
113 EXPECT_EQ(vsize1.psize, wrapper1.getParameterSize());
114 EXPECT_EQ(vsize1.vsize, wrapper1.getValueSize());
115 EXPECT_EQ(sizeof(effect_param_t) + EffectParamWrapper::padding(vsize1.psize) + vsize1.vsize,
116 wrapper1.getTotalSize());
117
118 EXPECT_EQ(vsize2.psize, wrapper2.getParameterSize());
119 EXPECT_EQ(vsize2.vsize, wrapper2.getValueSize());
120 EXPECT_EQ(sizeof(effect_param_t) + EffectParamWrapper::padding(vsize2.psize) + vsize2.vsize,
121 wrapper2.getTotalSize());
122 }
123
TEST(EffectParamWrapperTest,toString)124 TEST(EffectParamWrapperTest, toString) {
125 effect_param_t param = {.status = -1, .psize = 2, .vsize = 4};
126 const auto wrapper = EffectParamWrapper(param);
127 EXPECT_TRUE(wrapper.toString().find("effect_param_t: ") != std::string::npos);
128 EXPECT_TRUE(wrapper.toString().find("status: -1") != std::string::npos);
129 EXPECT_TRUE(wrapper.toString().find("p: 2") != std::string::npos);
130 EXPECT_TRUE(wrapper.toString().find("v: 4") != std::string::npos);
131 }
132
TEST(EffectParamWriterTest,writeReadFromData)133 TEST(EffectParamWriterTest, writeReadFromData) {
134 constexpr uint32_t dataLength = 8;
135 constexpr uint16_t testData[dataLength] = {0x200, 0x0, 0xffffu, 0xbead,
136 0xfefe, 0x5555, 0xeeee, 0x2};
137 uint16_t targetData[dataLength] = {0};
138 char buf[sizeof(effect_param_t) + sizeof(testData)];
139 effect_param_t *param = (effect_param_t *)(&buf);
140 param->psize = 0;
141 param->vsize = sizeof(testData);
142 auto wrapper = EffectParamWriter(*param);
143
144 // write testData into effect_param_t data buffer
145 ASSERT_EQ(OK, wrapper.writeToData(&testData, sizeof(testData) /* len */,
146 0 /* offset */, sizeof(testData) /* max */))
147 << wrapper.toString();
148
149 // read first half and compare
150 EXPECT_EQ(OK,
151 wrapper.readFromData(
152 &targetData, dataLength * sizeof(uint16_t) >> 1 /* len */,
153 0 /* offset */, dataLength * sizeof(uint16_t) >> 1 /* max */))
154 << wrapper.toString();
155 EXPECT_EQ(0, std::memcmp(&testData, &targetData,
156 dataLength * sizeof(uint16_t) >> 1));
157
158 // read second half and compare
159 std::memset(&targetData, 0, sizeof(testData));
160 EXPECT_EQ(OK, wrapper.readFromData(
161 &targetData, dataLength * sizeof(uint16_t) >> 1 /* len */,
162 dataLength * sizeof(uint16_t) >> 1 /* offset */,
163 sizeof(testData) /* max */))
164 << wrapper.toString();
165 EXPECT_EQ(0, std::memcmp(testData + dataLength / 2, &targetData,
166 dataLength * sizeof(uint16_t) >> 1));
167
168 // read all and compare
169 std::memset(&targetData, 0, sizeof(testData));
170 EXPECT_EQ(OK, wrapper.readFromData(&targetData, sizeof(testData), 0 /* offset */,
171 sizeof(testData) /* max */))
172 << wrapper.toString();
173 EXPECT_EQ(0, std::memcmp(&testData, &targetData, sizeof(testData)));
174 }
175
TEST(EffectParamWriterReaderTest,writeAndReadParameterOneByOne)176 TEST(EffectParamWriterReaderTest, writeAndReadParameterOneByOne) {
177 constexpr uint16_t data[11] = {
178 0x0f0f, 0x2020, 0xffff, 0xbead, 0x5e5e, 0x0 /* padding */,
179 0xe5e5, 0xeeee, 0x1111, 0x8888, 0xabab};
180 char buf[sizeof(effect_param_t) + sizeof(data)] = {};
181 effect_param_t *param = (effect_param_t *)(&buf);
182 param->psize = 5 * sizeof(uint16_t);
183 param->vsize = 5 * sizeof(uint16_t);
184 auto writer = EffectParamWriter(*param);
185 auto reader = EffectParamReader(*param);
186
187 // write testData into effect_param_t data buffer
188 EXPECT_EQ(OK, writer.writeToParameter(&data[0]));
189 EXPECT_EQ(OK, writer.writeToParameter(&data[1]));
190 EXPECT_EQ(OK, writer.writeToParameter(&data[2]));
191 EXPECT_EQ(OK, writer.writeToParameter(&data[3]));
192 EXPECT_EQ(OK, writer.writeToParameter(&data[4]));
193 EXPECT_NE(OK, writer.writeToParameter(&data[5])); // expect write error
194 EXPECT_EQ(OK, writer.writeToValue(&data[6]));
195 EXPECT_EQ(OK, writer.writeToValue(&data[7]));
196 EXPECT_EQ(OK, writer.writeToValue(&data[8]));
197 EXPECT_EQ(OK, writer.writeToValue(&data[9]));
198 EXPECT_EQ(OK, writer.writeToValue(&data[10]));
199 EXPECT_NE(OK, writer.writeToValue(&data[10])); // expect write error
200
201 // read and compare
202 uint16_t getData[12] = {};
203 EXPECT_EQ(OK, reader.readFromParameter(&getData[0]));
204 EXPECT_EQ(OK, reader.readFromParameter(&getData[1]));
205 EXPECT_EQ(OK, reader.readFromParameter(&getData[2]));
206 EXPECT_EQ(OK, reader.readFromParameter(&getData[3]));
207 EXPECT_EQ(OK, reader.readFromParameter(&getData[4]));
208 EXPECT_NE(OK, reader.readFromParameter(&getData[5])); // expect read error
209
210 EXPECT_EQ(OK, reader.readFromValue(&getData[6]));
211 EXPECT_EQ(OK, reader.readFromValue(&getData[7]));
212 EXPECT_EQ(OK, reader.readFromValue(&getData[8]));
213 EXPECT_EQ(OK, reader.readFromValue(&getData[9]));
214 EXPECT_EQ(OK, reader.readFromValue(&getData[10]));
215 EXPECT_NE(OK, reader.readFromValue(&getData[11])); // expect read error
216
217 EXPECT_EQ(0, std::memcmp(&buf[sizeof(effect_param_t)], &data, sizeof(data)));
218 EXPECT_EQ(0, std::memcmp(&getData, &data, sizeof(data)));
219 }
220
TEST(EffectParamWriterReaderTest,writeAndReadParameterN)221 TEST(EffectParamWriterReaderTest, writeAndReadParameterN) {
222 constexpr uint16_t data[11] = {
223 0x0f0f, 0x2020, 0xffff, 0x1111, 0xabab, 0x0 /* padding */,
224 0xe5e5, 0xeeee, 0xbead, 0x8888, 0x5e5e};
225 char buf[sizeof(effect_param_t) + sizeof(data)] = {};
226 effect_param_t *param = (effect_param_t *)(&buf);
227 param->psize = 5 * sizeof(uint16_t);
228 param->vsize = 5 * sizeof(uint16_t);
229 auto writer = EffectParamWriter(*param);
230 auto reader = EffectParamReader(*param);
231
232 // write testData into effect_param_t data buffer
233 EXPECT_EQ(OK, writer.writeToParameter(&data[0]));
234 EXPECT_EQ(OK, writer.writeToParameter(&data[1], 2));
235 EXPECT_EQ(OK, writer.writeToParameter(&data[3], 2));
236 EXPECT_NE(OK, writer.writeToParameter(&data[5])); // expect write error
237 EXPECT_EQ(OK, writer.writeToValue(&data[6], 3));
238 EXPECT_EQ(OK, writer.writeToValue(&data[9], 2));
239 EXPECT_NE(OK, writer.writeToValue(&data[10])); // expect write error
240
241 // read and compare
242 uint16_t getData[12] = {};
243 EXPECT_EQ(OK, reader.readFromParameter(&getData[0], 2));
244 EXPECT_EQ(OK, reader.readFromParameter(&getData[2]));
245 EXPECT_EQ(OK, reader.readFromParameter(&getData[3], 2));
246 EXPECT_NE(OK, reader.readFromParameter(&getData[5])); // expect read error
247
248 EXPECT_EQ(OK, reader.readFromValue(&getData[6]));
249 EXPECT_EQ(OK, reader.readFromValue(&getData[7], 2));
250 EXPECT_EQ(OK, reader.readFromValue(&getData[9], 2));
251 EXPECT_NE(OK, reader.readFromValue(&getData[11])); // expect read error
252
253 EXPECT_EQ(0, std::memcmp(&buf[sizeof(effect_param_t)], &data, sizeof(data)));
254 EXPECT_EQ(0, std::memcmp(&getData, &data, sizeof(data)));
255 }
256
TEST(EffectParamWriterReaderTest,writeAndReadParameterBlock)257 TEST(EffectParamWriterReaderTest, writeAndReadParameterBlock) {
258 constexpr uint16_t data[11] = {
259 0xe5e5, 0xeeee, 0x1111, 0x8888, 0xabab, 0x0, /* padding */
260 0x0f0f, 0x2020, 0xffff, 0xbead, 0x5e5e,
261 };
262 char buf[sizeof(effect_param_t) + sizeof(data)] = {};
263 effect_param_t *param = (effect_param_t *)(&buf);
264 param->psize = 5 * sizeof(uint16_t);
265 param->vsize = 5 * sizeof(uint16_t);
266 auto writer = EffectParamWriter(*param);
267 auto reader = EffectParamReader(*param);
268
269 // write testData into effect_param_t data buffer
270 EXPECT_EQ(OK, writer.writeToParameter(&data[0], 5));
271 EXPECT_NE(OK, writer.writeToParameter(&data[5])); // expect write error
272 EXPECT_EQ(OK, writer.writeToValue(&data[6], 5));
273 EXPECT_NE(OK, writer.writeToValue(&data[10])); // expect write error
274 writer.finishValueWrite();
275 EXPECT_EQ(5 * sizeof(uint16_t), writer.getValueSize());
276 EXPECT_EQ(sizeof(effect_param_t) +
277 6 * sizeof(uint16_t) /* padded parameter */ +
278 5 * sizeof(uint16_t),
279 writer.getTotalSize())
280 << writer.toString();
281
282 // read and compare
283 uint16_t getData[12] = {};
284 EXPECT_EQ(OK, reader.readFromParameter(&getData[0], 5));
285 EXPECT_NE(OK, reader.readFromParameter(&getData[5])); // expect read error
286
287 EXPECT_EQ(OK, reader.readFromValue(&getData[6], 5));
288 EXPECT_NE(OK, reader.readFromValue(&getData[11])); // expect read error
289
290 EXPECT_EQ(0, std::memcmp(&buf[sizeof(effect_param_t)], &data, sizeof(data)));
291 EXPECT_EQ(0, std::memcmp(&getData, &data, sizeof(data)));
292 }
293
TEST(EffectParamWriterTest,setStatus)294 TEST(EffectParamWriterTest, setStatus) {
295 effect_param_t param = {.status = -1, .psize = 2, .vsize = 4};
296 auto wrapper = EffectParamWriter(param);
297 EXPECT_EQ(-1, wrapper.getStatus()) << wrapper.toString();
298 wrapper.setStatus(0);
299 EXPECT_EQ(0, wrapper.getStatus()) << wrapper.toString();
300 EXPECT_EQ(wrapper.getStatus(), param.status);
301 wrapper.setStatus(0x10);
302 EXPECT_EQ(0x10, wrapper.getStatus()) << wrapper.toString();
303 EXPECT_EQ(wrapper.getStatus(), param.status) << wrapper.toString();
304 }
305
TEST(EffectParamWriterReaderTest,writeAndReadParameterDiffSize)306 TEST(EffectParamWriterReaderTest, writeAndReadParameterDiffSize) {
307 constexpr uint16_t data[11] = {
308 0xbead, 0x5e5e, 0x0f0f, 0x2020, 0xffff, 0x0 /* padding */,
309 0xe5e5, 0xeeee, 0x1111, 0x8888, 0xabab};
310 char buf[sizeof(effect_param_t) + sizeof(data)] = {};
311 effect_param_t *param = (effect_param_t *)(&buf);
312 param->psize = 5 * sizeof(uint16_t);
313 param->vsize = 5 * sizeof(uint16_t);
314 auto writer = EffectParamWriter(*param);
315 auto reader = EffectParamReader(*param);
316
317 // write testData into effect_param_t data buffer
318 EXPECT_EQ(OK, writer.writeToParameter(&data[0]));
319 EXPECT_EQ(OK, writer.writeToParameter((uint32_t *)&data[1]));
320 EXPECT_EQ(OK, writer.writeToParameter((uint32_t *)&data[3]));
321 EXPECT_NE(OK, writer.writeToParameter(&data[5])); // expect write error
322 EXPECT_EQ(OK, writer.writeToValue((uint32_t *)&data[6], 2));
323 EXPECT_EQ(OK, writer.writeToValue(&data[10]));
324 writer.finishValueWrite();
325 EXPECT_EQ(5 * sizeof(uint16_t), writer.getValueSize());
326 EXPECT_EQ(sizeof(effect_param_t) + sizeof(data), writer.getTotalSize())
327 << writer.toString();
328 EXPECT_NE(OK, writer.writeToValue(&data[10])); // expect write error
329 writer.finishValueWrite();
330 EXPECT_EQ(5 * sizeof(uint16_t), writer.getValueSize());
331 EXPECT_EQ(sizeof(effect_param_t) + sizeof(data), writer.getTotalSize())
332 << writer.toString();
333
334 // read and compare
335 uint16_t getData[12] = {};
336 EXPECT_EQ(OK, reader.readFromParameter((uint32_t *)&getData[0], 2));
337 EXPECT_EQ(OK, reader.readFromParameter(&getData[4]));
338 EXPECT_NE(OK, reader.readFromParameter(&getData[5])); // expect read error
339
340 EXPECT_EQ(OK, reader.readFromValue(&getData[6]));
341 EXPECT_EQ(OK, reader.readFromValue((uint32_t *)&getData[7]));
342 EXPECT_EQ(OK, reader.readFromValue((uint32_t *)&getData[9]));
343 EXPECT_NE(OK, reader.readFromValue(&getData[11])); // expect read error
344
345 EXPECT_EQ(0, std::memcmp(&buf[sizeof(effect_param_t)], &data, sizeof(data)));
346 EXPECT_EQ(0, std::memcmp(&getData, &data, sizeof(data)));
347 }
348
TEST(EffectParamWriterTest,overwriteWithSameSize)349 TEST(EffectParamWriterTest, overwriteWithSameSize) {
350 constexpr uint32_t pSizeInShorts = 5, vSizeInShorts = 4;
351 constexpr uint16_t
352 data[EffectParamWrapper::padding(pSizeInShorts) + vSizeInShorts] = {
353 // parameter
354 0xe5e5, 0xeeee, 0x1111, 0x8888, 0xabab, 0x0 /* padding */,
355 // value
356 0x0f0f, 0x2020, 0xffff, 0xbead};
357 char buf[sizeof(effect_param_t) + sizeof(data)] = {};
358 effect_param_t *param = (effect_param_t *)(&buf);
359 param->psize = pSizeInShorts * sizeof(uint16_t); // padded to 6 * sizeof(uint16_t)
360 param->vsize = vSizeInShorts * sizeof(uint16_t);
361 auto writer = EffectParamWriter(*param);
362 EXPECT_EQ(OK, writer.writeToParameter(&data[0], pSizeInShorts));
363 EXPECT_EQ(OK, writer.writeToValue(&data[6], vSizeInShorts));
364 writer.finishValueWrite();
365
366 constexpr uint32_t newPSizeInShorts = 3, newVSizeInShorts = 6;
367 constexpr uint16_t
368 newdata[EffectParamWrapper::padding(newPSizeInShorts) + newVSizeInShorts] = {
369 // parameter
370 0xffff, 0x2020, 0xbead, 0x0 /* padding */,
371 // value
372 0xabab, 0xeeee, 0x0f0f, 0x5e5e, 0x8888, 0xe5e5};
373 char newbuf[sizeof(effect_param_t) + sizeof(newdata)] = {};
374 effect_param_t *newparam = (effect_param_t *)(&newbuf);
375 newparam->psize = newPSizeInShorts * sizeof(uint16_t); // padded to 4 * sizeof(uint16_t)
376 newparam->vsize = newVSizeInShorts * sizeof(uint16_t);
377 auto newwriter = EffectParamWriter(*newparam);
378 EXPECT_EQ(OK, newwriter.writeToParameter(newdata, newPSizeInShorts));
379 EXPECT_EQ(OK, newwriter.writeToValue(
380 &newdata[EffectParamWrapper::padding(newPSizeInShorts)],
381 newVSizeInShorts));
382 newwriter.finishValueWrite();
383
384 EXPECT_EQ(OK, writer.overwrite(newwriter.getEffectParam()));
385 EXPECT_EQ(0,
386 std::memcmp(&writer.getEffectParam(), &newwriter.getEffectParam(),
387 newwriter.getTotalSize()));
388 EXPECT_EQ(newwriter.getParameterSize(), writer.getParameterSize());
389 EXPECT_EQ(newwriter.getValueSize(), writer.getValueSize());
390 }
391
TEST(EffectParamWriterTest,overwriteWithLargerSize)392 TEST(EffectParamWriterTest, overwriteWithLargerSize) {
393 constexpr uint32_t pSizeInShorts = 5, vSizeInShorts = 4;
394 constexpr uint16_t data[EffectParamWrapper::padding(pSizeInShorts) + vSizeInShorts] = {
395 // parameter
396 0xe5e5, 0xeeee, 0x1111, 0x8888, 0xabab, 0x0 /* padding */,
397 // value
398 0x0f0f, 0x2020, 0xffff, 0xbead};
399 char buf[sizeof(effect_param_t) + sizeof(data)] = {};
400 effect_param_t *param = (effect_param_t *)(&buf);
401 param->psize = pSizeInShorts * sizeof(uint16_t); // padded to 6 * sizeof(uint16_t)
402 param->vsize = vSizeInShorts * sizeof(uint16_t);
403 auto writer = EffectParamWriter(*param);
404 EXPECT_EQ(OK, writer.writeToParameter(&data[0], pSizeInShorts));
405 EXPECT_EQ(OK, writer.writeToValue(&data[6], vSizeInShorts));
406 writer.finishValueWrite();
407
408 constexpr uint32_t newPSizeInShorts = 3, newVSizeInShorts = 8;
409 constexpr uint16_t
410 newdata[EffectParamWrapper::padding(newPSizeInShorts) + newVSizeInShorts] = {
411 // parameter
412 0xffff, 0x2020, 0xbead, 0x0 /* padding */,
413 // value
414 0xabab, 0xeeee, 0x0f0f, 0x5e5e, 0x8888, 0xe5e5, 0x5f5f, 0x1234};
415 char newbuf[sizeof(effect_param_t) + sizeof(newdata)] = {};
416 effect_param_t *newparam = (effect_param_t *)(&newbuf);
417 newparam->psize = newPSizeInShorts * sizeof(uint16_t); // padded to 4 * sizeof(uint16_t)
418 newparam->vsize = newVSizeInShorts * sizeof(uint16_t);
419 auto newwriter = EffectParamWriter(*newparam);
420 EXPECT_EQ(OK, newwriter.writeToParameter(newdata, newPSizeInShorts));
421 EXPECT_EQ(OK, newwriter.writeToValue(
422 &newdata[EffectParamWrapper::padding(newPSizeInShorts)],
423 newVSizeInShorts));
424 newwriter.finishValueWrite();
425
426 EXPECT_NE(OK, writer.overwrite(newwriter.getEffectParam()));
427 }
428
TEST(AudioEffectsUtilsTest,EqualityOperator)429 TEST(AudioEffectsUtilsTest, EqualityOperator) {
430 audio_uuid_t uuid1 = {0x12345678, 0x1234, 0x5678, 0x90AB, {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01}};
431 audio_uuid_t uuid2 = {0x12345678, 0x1234, 0x5678, 0x90AB, {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01}};
432
433 EXPECT_TRUE(uuid1 == uuid2);
434 EXPECT_FALSE(uuid1 != uuid2);
435 }
436
TEST(AudioEffectsUtilsTest,InequalityOperator)437 TEST(AudioEffectsUtilsTest, InequalityOperator) {
438 audio_uuid_t uuid1 = {0x12345678, 0x1234, 0x5678, 0x90AB, {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01}};
439 audio_uuid_t uuid2 = {0x87654321, 0x4321, 0x8765, 0xBA09, {0x01, 0x00, 0xEF, 0xBE, 0xAD, 0xDE}};
440
441 EXPECT_TRUE(uuid1 != uuid2);
442 EXPECT_FALSE(uuid1 == uuid2);
443 }
444
TEST(AudioEffectsUtilsTest,EqualityWithModifiedNode)445 TEST(AudioEffectsUtilsTest, EqualityWithModifiedNode) {
446 audio_uuid_t uuid1 = {0x12345678, 0x1234, 0x5678, 0x90AB, {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01}};
447 audio_uuid_t uuid2 = uuid1;
448 uuid2.node[5] = 0x02; // Modify one byte in the `node` array
449
450 EXPECT_FALSE(uuid1 == uuid2);
451 EXPECT_TRUE(uuid1 != uuid2);
452 }
453
TEST(AudioEffectsUtilsTest,ToString)454 TEST(AudioEffectsUtilsTest, ToString) {
455 audio_uuid_t uuid = {0x12345678, 0x1234, 0x5678, 0x90AB, {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01}};
456 std::string expected = "12345678-1234-5678-90ab-deadbeef0001";
457
458 EXPECT_EQ(ToString(uuid), expected);
459 }
460
TEST(AudioEffectsUtilsTest,ToStringUpperCase)461 TEST(AudioEffectsUtilsTest, ToStringUpperCase) {
462 audio_uuid_t uuid = {0x87654321, 0x4321, 0x8765, 0xBA09, {0x01, 0x00, 0xEF, 0xBE, 0xAD, 0xDE}};
463 std::string expected = "87654321-4321-8765-ba09-0100efbeadde";
464
465 EXPECT_EQ(ToString(uuid), expected);
466 }
467
TEST(AudioEffectsUtilsTest,ToStringAllZeros)468 TEST(AudioEffectsUtilsTest, ToStringAllZeros) {
469 audio_uuid_t uuid = {0, 0, 0, 0, {0, 0, 0, 0, 0, 0}};
470 std::string expected = "00000000-0000-0000-0000-000000000000";
471
472 EXPECT_EQ(ToString(uuid), expected);
473 }
474
TEST(AudioEffectsUtilsTest,ToStringBoundaryValues)475 TEST(AudioEffectsUtilsTest, ToStringBoundaryValues) {
476 audio_uuid_t uuid = {0xFFFFFFFF, 0xFFFF, 0xFFFF, 0xFFFF, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
477 std::string expected = "ffffffff-ffff-ffff-ffff-ffffffffffff";
478
479 EXPECT_EQ(ToString(uuid), expected);
480 }
481