You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
424 lines
19 KiB
424 lines
19 KiB
/*
|
|
* Copyright (C) 2023 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <cstring>
|
|
#include <limits>
|
|
#include <locale>
|
|
|
|
#define LOG_TAG "EffectParamWrapper_Test"
|
|
#include <log/log.h>
|
|
#include <system/audio_effects/audio_effects_utils.h>
|
|
|
|
using namespace android;
|
|
using android::effect::utils::EffectParamReader;
|
|
using android::effect::utils::EffectParamWrapper;
|
|
using android::effect::utils::EffectParamWriter;
|
|
|
|
TEST(EffectParamWrapperTest, setAndGetMatches) {
|
|
effect_param_t param = {.psize = 2, .vsize = 0x10};
|
|
const auto wrapper = EffectParamWrapper(param);
|
|
effect_param_t target = wrapper.getEffectParam();
|
|
const auto targetWrapper = EffectParamWrapper(target);
|
|
EXPECT_TRUE(0 == std::memcmp(¶m, &target, sizeof(effect_param_t)));
|
|
EXPECT_EQ(targetWrapper, wrapper);
|
|
}
|
|
|
|
TEST(EffectParamWrapperTest, validateCmdSize) {
|
|
effect_param_t param = {.psize = 1, .vsize = 4};
|
|
const auto wrapper = EffectParamWrapper(param);
|
|
size_t minCmdSize = sizeof(effect_param_t) +
|
|
wrapper.getPaddedParameterSize() +
|
|
wrapper.getValueSize();
|
|
EXPECT_FALSE(wrapper.validateCmdSize(minCmdSize - 1));
|
|
EXPECT_TRUE(wrapper.validateCmdSize(minCmdSize));
|
|
EXPECT_TRUE(wrapper.validateCmdSize(minCmdSize + 1));
|
|
}
|
|
|
|
TEST(EffectParamWrapperTest, validateCmdSizeOverflow) {
|
|
effect_param_t param = {.psize = std::numeric_limits<uint32_t>::max(),
|
|
.vsize = std::numeric_limits<uint32_t>::max()};
|
|
const auto wrapper = EffectParamWrapper(param);
|
|
uint64_t minCmdSize = (uint64_t)sizeof(effect_param_t) +
|
|
wrapper.getPaddedParameterSize() +
|
|
wrapper.getValueSize();
|
|
EXPECT_FALSE(wrapper.validateCmdSize(minCmdSize - 1));
|
|
EXPECT_TRUE(wrapper.validateCmdSize(minCmdSize));
|
|
EXPECT_TRUE(wrapper.validateCmdSize(minCmdSize + 1));
|
|
}
|
|
|
|
TEST(EffectParamWrapperTest, validateParamValueSize) {
|
|
effect_param_t param = {.psize = 1, .vsize = 4};
|
|
const auto wrapper = EffectParamWrapper(param);
|
|
EXPECT_TRUE(wrapper.validateParamValueSize(param.psize, param.vsize));
|
|
EXPECT_TRUE(wrapper.validateParamValueSize(0, param.vsize));
|
|
EXPECT_TRUE(wrapper.validateParamValueSize(param.psize, 0));
|
|
EXPECT_FALSE(wrapper.validateParamValueSize(param.psize + 1, 0));
|
|
EXPECT_FALSE(wrapper.validateParamValueSize(0, param.vsize + 1));
|
|
}
|
|
|
|
TEST(EffectParamWrapperTest, padding) {
|
|
for (size_t i = 0; i < 0x100; i++) {
|
|
EXPECT_EQ(
|
|
sizeof(uint32_t) * ((i + sizeof(uint32_t) - 1) / sizeof(uint32_t)),
|
|
EffectParamWrapper::padding(i))
|
|
<< i;
|
|
}
|
|
}
|
|
|
|
TEST(EffectParamWrapperTest, getPaddedParameterSize) {
|
|
effect_param_t psize1 = {.psize = 1};
|
|
const auto wrapper1 = EffectParamWrapper(psize1);
|
|
EXPECT_EQ(4, wrapper1.getPaddedParameterSize());
|
|
EXPECT_EQ(4, wrapper1.padding(psize1.psize));
|
|
|
|
effect_param_t psize4 = {.psize = 4};
|
|
const auto wrapper4 = EffectParamWrapper(psize4);
|
|
EXPECT_EQ(4, wrapper4.getPaddedParameterSize());
|
|
EXPECT_EQ(wrapper4.getPaddedParameterSize(), wrapper4.padding(psize4.psize));
|
|
|
|
effect_param_t psize6 = {.psize = 6};
|
|
const auto wrapper6 = EffectParamWrapper(psize6);
|
|
EXPECT_EQ(8, wrapper6.getPaddedParameterSize());
|
|
EXPECT_EQ(wrapper6.getPaddedParameterSize(), wrapper6.padding(psize6.psize));
|
|
}
|
|
|
|
TEST(EffectParamWrapperTest, getPVSize) {
|
|
effect_param_t vsize1 = {.vsize = 1, .psize = 0xff};
|
|
const auto wrapper1 = EffectParamWrapper(vsize1);
|
|
EXPECT_EQ(vsize1.vsize, wrapper1.getValueSize());
|
|
|
|
effect_param_t vsize2 = {.vsize = 0xff, .psize = 0xbe};
|
|
const auto wrapper2 = EffectParamWrapper(vsize2);
|
|
EXPECT_EQ(vsize2.vsize, wrapper2.getValueSize());
|
|
|
|
EXPECT_EQ(vsize1.psize, wrapper1.getParameterSize());
|
|
EXPECT_EQ(vsize1.vsize, wrapper1.getValueSize());
|
|
EXPECT_EQ(sizeof(effect_param_t) + EffectParamWrapper::padding(vsize1.psize) + vsize1.vsize,
|
|
wrapper1.getTotalSize());
|
|
|
|
EXPECT_EQ(vsize2.psize, wrapper2.getParameterSize());
|
|
EXPECT_EQ(vsize2.vsize, wrapper2.getValueSize());
|
|
EXPECT_EQ(sizeof(effect_param_t) + EffectParamWrapper::padding(vsize2.psize) + vsize2.vsize,
|
|
wrapper2.getTotalSize());
|
|
}
|
|
|
|
TEST(EffectParamWrapperTest, toString) {
|
|
effect_param_t param = {.status = -1, .psize = 2, .vsize = 4};
|
|
const auto wrapper = EffectParamWrapper(param);
|
|
EXPECT_TRUE(wrapper.toString().find("effect_param_t: ") != std::string::npos);
|
|
EXPECT_TRUE(wrapper.toString().find("status: -1") != std::string::npos);
|
|
EXPECT_TRUE(wrapper.toString().find("p: 2") != std::string::npos);
|
|
EXPECT_TRUE(wrapper.toString().find("v: 4") != std::string::npos);
|
|
}
|
|
|
|
TEST(EffectParamWriterTest, writeReadFromData) {
|
|
constexpr uint32_t dataLength = 8;
|
|
constexpr uint16_t testData[dataLength] = {0x200, 0x0, 0xffffu, 0xbead,
|
|
0xfefe, 0x5555, 0xeeee, 0x2};
|
|
uint16_t targetData[dataLength] = {0};
|
|
char buf[sizeof(effect_param_t) + sizeof(testData)];
|
|
effect_param_t *param = (effect_param_t *)(&buf);
|
|
param->psize = 0;
|
|
param->vsize = sizeof(testData);
|
|
auto wrapper = EffectParamWriter(*param);
|
|
|
|
// write testData into effect_param_t data buffer
|
|
ASSERT_EQ(OK, wrapper.writeToData(&testData, sizeof(testData) /* len */,
|
|
0 /* offset */, sizeof(testData) /* max */))
|
|
<< wrapper.toString();
|
|
|
|
// read first half and compare
|
|
EXPECT_EQ(OK,
|
|
wrapper.readFromData(
|
|
&targetData, dataLength * sizeof(uint16_t) >> 1 /* len */,
|
|
0 /* offset */, dataLength * sizeof(uint16_t) >> 1 /* max */))
|
|
<< wrapper.toString();
|
|
EXPECT_EQ(0, std::memcmp(&testData, &targetData,
|
|
dataLength * sizeof(uint16_t) >> 1));
|
|
|
|
// read second half and compare
|
|
std::memset(&targetData, 0, sizeof(testData));
|
|
EXPECT_EQ(OK, wrapper.readFromData(
|
|
&targetData, dataLength * sizeof(uint16_t) >> 1 /* len */,
|
|
dataLength * sizeof(uint16_t) >> 1 /* offset */,
|
|
sizeof(testData) /* max */))
|
|
<< wrapper.toString();
|
|
EXPECT_EQ(0, std::memcmp(testData + dataLength / 2, &targetData,
|
|
dataLength * sizeof(uint16_t) >> 1));
|
|
|
|
// read all and compare
|
|
std::memset(&targetData, 0, sizeof(testData));
|
|
EXPECT_EQ(OK, wrapper.readFromData(&targetData, sizeof(testData), 0 /* offset */,
|
|
sizeof(testData) /* max */))
|
|
<< wrapper.toString();
|
|
EXPECT_EQ(0, std::memcmp(&testData, &targetData, sizeof(testData)));
|
|
}
|
|
|
|
TEST(EffectParamWriterReaderTest, writeAndReadParameterOneByOne) {
|
|
constexpr uint16_t data[11] = {
|
|
0x0f0f, 0x2020, 0xffff, 0xbead, 0x5e5e, 0x0 /* padding */,
|
|
0xe5e5, 0xeeee, 0x1111, 0x8888, 0xabab};
|
|
char buf[sizeof(effect_param_t) + sizeof(data)] = {};
|
|
effect_param_t *param = (effect_param_t *)(&buf);
|
|
param->psize = 5 * sizeof(uint16_t);
|
|
param->vsize = 5 * sizeof(uint16_t);
|
|
auto writer = EffectParamWriter(*param);
|
|
auto reader = EffectParamReader(*param);
|
|
|
|
// write testData into effect_param_t data buffer
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[0]));
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[1]));
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[2]));
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[3]));
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[4]));
|
|
EXPECT_NE(OK, writer.writeToParameter(&data[5])); // expect write error
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[6]));
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[7]));
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[8]));
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[9]));
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[10]));
|
|
EXPECT_NE(OK, writer.writeToValue(&data[10])); // expect write error
|
|
|
|
// read and compare
|
|
uint16_t getData[12] = {};
|
|
EXPECT_EQ(OK, reader.readFromParameter(&getData[0]));
|
|
EXPECT_EQ(OK, reader.readFromParameter(&getData[1]));
|
|
EXPECT_EQ(OK, reader.readFromParameter(&getData[2]));
|
|
EXPECT_EQ(OK, reader.readFromParameter(&getData[3]));
|
|
EXPECT_EQ(OK, reader.readFromParameter(&getData[4]));
|
|
EXPECT_NE(OK, reader.readFromParameter(&getData[5])); // expect read error
|
|
|
|
EXPECT_EQ(OK, reader.readFromValue(&getData[6]));
|
|
EXPECT_EQ(OK, reader.readFromValue(&getData[7]));
|
|
EXPECT_EQ(OK, reader.readFromValue(&getData[8]));
|
|
EXPECT_EQ(OK, reader.readFromValue(&getData[9]));
|
|
EXPECT_EQ(OK, reader.readFromValue(&getData[10]));
|
|
EXPECT_NE(OK, reader.readFromValue(&getData[11])); // expect read error
|
|
|
|
EXPECT_EQ(0, std::memcmp(&buf[sizeof(effect_param_t)], &data, sizeof(data)));
|
|
EXPECT_EQ(0, std::memcmp(&getData, &data, sizeof(data)));
|
|
}
|
|
|
|
TEST(EffectParamWriterReaderTest, writeAndReadParameterN) {
|
|
constexpr uint16_t data[11] = {
|
|
0x0f0f, 0x2020, 0xffff, 0x1111, 0xabab, 0x0 /* padding */,
|
|
0xe5e5, 0xeeee, 0xbead, 0x8888, 0x5e5e};
|
|
char buf[sizeof(effect_param_t) + sizeof(data)] = {};
|
|
effect_param_t *param = (effect_param_t *)(&buf);
|
|
param->psize = 5 * sizeof(uint16_t);
|
|
param->vsize = 5 * sizeof(uint16_t);
|
|
auto writer = EffectParamWriter(*param);
|
|
auto reader = EffectParamReader(*param);
|
|
|
|
// write testData into effect_param_t data buffer
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[0]));
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[1], 2));
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[3], 2));
|
|
EXPECT_NE(OK, writer.writeToParameter(&data[5])); // expect write error
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[6], 3));
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[9], 2));
|
|
EXPECT_NE(OK, writer.writeToValue(&data[10])); // expect write error
|
|
|
|
// read and compare
|
|
uint16_t getData[12] = {};
|
|
EXPECT_EQ(OK, reader.readFromParameter(&getData[0], 2));
|
|
EXPECT_EQ(OK, reader.readFromParameter(&getData[2]));
|
|
EXPECT_EQ(OK, reader.readFromParameter(&getData[3], 2));
|
|
EXPECT_NE(OK, reader.readFromParameter(&getData[5])); // expect read error
|
|
|
|
EXPECT_EQ(OK, reader.readFromValue(&getData[6]));
|
|
EXPECT_EQ(OK, reader.readFromValue(&getData[7], 2));
|
|
EXPECT_EQ(OK, reader.readFromValue(&getData[9], 2));
|
|
EXPECT_NE(OK, reader.readFromValue(&getData[11])); // expect read error
|
|
|
|
EXPECT_EQ(0, std::memcmp(&buf[sizeof(effect_param_t)], &data, sizeof(data)));
|
|
EXPECT_EQ(0, std::memcmp(&getData, &data, sizeof(data)));
|
|
}
|
|
|
|
TEST(EffectParamWriterReaderTest, writeAndReadParameterBlock) {
|
|
constexpr uint16_t data[11] = {
|
|
0xe5e5, 0xeeee, 0x1111, 0x8888, 0xabab, 0x0, /* padding */
|
|
0x0f0f, 0x2020, 0xffff, 0xbead, 0x5e5e,
|
|
};
|
|
char buf[sizeof(effect_param_t) + sizeof(data)] = {};
|
|
effect_param_t *param = (effect_param_t *)(&buf);
|
|
param->psize = 5 * sizeof(uint16_t);
|
|
param->vsize = 5 * sizeof(uint16_t);
|
|
auto writer = EffectParamWriter(*param);
|
|
auto reader = EffectParamReader(*param);
|
|
|
|
// write testData into effect_param_t data buffer
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[0], 5));
|
|
EXPECT_NE(OK, writer.writeToParameter(&data[5])); // expect write error
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[6], 5));
|
|
EXPECT_NE(OK, writer.writeToValue(&data[10])); // expect write error
|
|
writer.finishValueWrite();
|
|
EXPECT_EQ(5 * sizeof(uint16_t), writer.getValueSize());
|
|
EXPECT_EQ(sizeof(effect_param_t) +
|
|
6 * sizeof(uint16_t) /* padded parameter */ +
|
|
5 * sizeof(uint16_t),
|
|
writer.getTotalSize())
|
|
<< writer.toString();
|
|
|
|
// read and compare
|
|
uint16_t getData[12] = {};
|
|
EXPECT_EQ(OK, reader.readFromParameter(&getData[0], 5));
|
|
EXPECT_NE(OK, reader.readFromParameter(&getData[5])); // expect read error
|
|
|
|
EXPECT_EQ(OK, reader.readFromValue(&getData[6], 5));
|
|
EXPECT_NE(OK, reader.readFromValue(&getData[11])); // expect read error
|
|
|
|
EXPECT_EQ(0, std::memcmp(&buf[sizeof(effect_param_t)], &data, sizeof(data)));
|
|
EXPECT_EQ(0, std::memcmp(&getData, &data, sizeof(data)));
|
|
}
|
|
|
|
TEST(EffectParamWriterTest, setStatus) {
|
|
effect_param_t param = {.status = -1, .psize = 2, .vsize = 4};
|
|
auto wrapper = EffectParamWriter(param);
|
|
EXPECT_EQ(-1, wrapper.getStatus()) << wrapper.toString();
|
|
wrapper.setStatus(0);
|
|
EXPECT_EQ(0, wrapper.getStatus()) << wrapper.toString();
|
|
EXPECT_EQ(wrapper.getStatus(), param.status);
|
|
wrapper.setStatus(0x10);
|
|
EXPECT_EQ(0x10, wrapper.getStatus()) << wrapper.toString();
|
|
EXPECT_EQ(wrapper.getStatus(), param.status) << wrapper.toString();
|
|
}
|
|
|
|
TEST(EffectParamWriterReaderTest, writeAndReadParameterDiffSize) {
|
|
constexpr uint16_t data[11] = {
|
|
0xbead, 0x5e5e, 0x0f0f, 0x2020, 0xffff, 0x0 /* padding */,
|
|
0xe5e5, 0xeeee, 0x1111, 0x8888, 0xabab};
|
|
char buf[sizeof(effect_param_t) + sizeof(data)] = {};
|
|
effect_param_t *param = (effect_param_t *)(&buf);
|
|
param->psize = 5 * sizeof(uint16_t);
|
|
param->vsize = 5 * sizeof(uint16_t);
|
|
auto writer = EffectParamWriter(*param);
|
|
auto reader = EffectParamReader(*param);
|
|
|
|
// write testData into effect_param_t data buffer
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[0]));
|
|
EXPECT_EQ(OK, writer.writeToParameter((uint32_t *)&data[1]));
|
|
EXPECT_EQ(OK, writer.writeToParameter((uint32_t *)&data[3]));
|
|
EXPECT_NE(OK, writer.writeToParameter(&data[5])); // expect write error
|
|
EXPECT_EQ(OK, writer.writeToValue((uint32_t *)&data[6], 2));
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[10]));
|
|
writer.finishValueWrite();
|
|
EXPECT_EQ(5 * sizeof(uint16_t), writer.getValueSize());
|
|
EXPECT_EQ(sizeof(effect_param_t) + sizeof(data), writer.getTotalSize())
|
|
<< writer.toString();
|
|
EXPECT_NE(OK, writer.writeToValue(&data[10])); // expect write error
|
|
writer.finishValueWrite();
|
|
EXPECT_EQ(5 * sizeof(uint16_t), writer.getValueSize());
|
|
EXPECT_EQ(sizeof(effect_param_t) + sizeof(data), writer.getTotalSize())
|
|
<< writer.toString();
|
|
|
|
// read and compare
|
|
uint16_t getData[12] = {};
|
|
EXPECT_EQ(OK, reader.readFromParameter((uint32_t *)&getData[0], 2));
|
|
EXPECT_EQ(OK, reader.readFromParameter(&getData[4]));
|
|
EXPECT_NE(OK, reader.readFromParameter(&getData[5])); // expect read error
|
|
|
|
EXPECT_EQ(OK, reader.readFromValue(&getData[6]));
|
|
EXPECT_EQ(OK, reader.readFromValue((uint32_t *)&getData[7]));
|
|
EXPECT_EQ(OK, reader.readFromValue((uint32_t *)&getData[9]));
|
|
EXPECT_NE(OK, reader.readFromValue(&getData[11])); // expect read error
|
|
|
|
EXPECT_EQ(0, std::memcmp(&buf[sizeof(effect_param_t)], &data, sizeof(data)));
|
|
EXPECT_EQ(0, std::memcmp(&getData, &data, sizeof(data)));
|
|
}
|
|
|
|
TEST(EffectParamWriterTest, overwriteWithSameSize) {
|
|
constexpr uint32_t pSizeInShorts = 5, vSizeInShorts = 4;
|
|
constexpr uint16_t
|
|
data[EffectParamWrapper::padding(pSizeInShorts) + vSizeInShorts] = {
|
|
// parameter
|
|
0xe5e5, 0xeeee, 0x1111, 0x8888, 0xabab, 0x0 /* padding */,
|
|
// value
|
|
0x0f0f, 0x2020, 0xffff, 0xbead};
|
|
char buf[sizeof(effect_param_t) + sizeof(data)] = {};
|
|
effect_param_t *param = (effect_param_t *)(&buf);
|
|
param->psize = pSizeInShorts * sizeof(uint16_t); // padded to 6 * sizeof(uint16_t)
|
|
param->vsize = vSizeInShorts * sizeof(uint16_t);
|
|
auto writer = EffectParamWriter(*param);
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[0], pSizeInShorts));
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[6], vSizeInShorts));
|
|
writer.finishValueWrite();
|
|
|
|
constexpr uint32_t newPSizeInShorts = 3, newVSizeInShorts = 6;
|
|
constexpr uint16_t
|
|
newdata[EffectParamWrapper::padding(newPSizeInShorts) + newVSizeInShorts] = {
|
|
// parameter
|
|
0xffff, 0x2020, 0xbead, 0x0 /* padding */,
|
|
// value
|
|
0xabab, 0xeeee, 0x0f0f, 0x5e5e, 0x8888, 0xe5e5};
|
|
char newbuf[sizeof(effect_param_t) + sizeof(newdata)] = {};
|
|
effect_param_t *newparam = (effect_param_t *)(&newbuf);
|
|
newparam->psize = newPSizeInShorts * sizeof(uint16_t); // padded to 4 * sizeof(uint16_t)
|
|
newparam->vsize = newVSizeInShorts * sizeof(uint16_t);
|
|
auto newwriter = EffectParamWriter(*newparam);
|
|
EXPECT_EQ(OK, newwriter.writeToParameter(newdata, newPSizeInShorts));
|
|
EXPECT_EQ(OK, newwriter.writeToValue(
|
|
&newdata[EffectParamWrapper::padding(newPSizeInShorts)],
|
|
newVSizeInShorts));
|
|
newwriter.finishValueWrite();
|
|
|
|
EXPECT_EQ(OK, writer.overwrite(newwriter.getEffectParam()));
|
|
EXPECT_EQ(0,
|
|
std::memcmp(&writer.getEffectParam(), &newwriter.getEffectParam(),
|
|
newwriter.getTotalSize()));
|
|
EXPECT_EQ(newwriter.getParameterSize(), writer.getParameterSize());
|
|
EXPECT_EQ(newwriter.getValueSize(), writer.getValueSize());
|
|
}
|
|
|
|
TEST(EffectParamWriterTest, overwriteWithLargerSize) {
|
|
constexpr uint32_t pSizeInShorts = 5, vSizeInShorts = 4;
|
|
constexpr uint16_t data[EffectParamWrapper::padding(pSizeInShorts) + vSizeInShorts] = {
|
|
// parameter
|
|
0xe5e5, 0xeeee, 0x1111, 0x8888, 0xabab, 0x0 /* padding */,
|
|
// value
|
|
0x0f0f, 0x2020, 0xffff, 0xbead};
|
|
char buf[sizeof(effect_param_t) + sizeof(data)] = {};
|
|
effect_param_t *param = (effect_param_t *)(&buf);
|
|
param->psize = pSizeInShorts * sizeof(uint16_t); // padded to 6 * sizeof(uint16_t)
|
|
param->vsize = vSizeInShorts * sizeof(uint16_t);
|
|
auto writer = EffectParamWriter(*param);
|
|
EXPECT_EQ(OK, writer.writeToParameter(&data[0], pSizeInShorts));
|
|
EXPECT_EQ(OK, writer.writeToValue(&data[6], vSizeInShorts));
|
|
writer.finishValueWrite();
|
|
|
|
constexpr uint32_t newPSizeInShorts = 3, newVSizeInShorts = 8;
|
|
constexpr uint16_t
|
|
newdata[EffectParamWrapper::padding(newPSizeInShorts) + newVSizeInShorts] = {
|
|
// parameter
|
|
0xffff, 0x2020, 0xbead, 0x0 /* padding */,
|
|
// value
|
|
0xabab, 0xeeee, 0x0f0f, 0x5e5e, 0x8888, 0xe5e5, 0x5f5f, 0x1234};
|
|
char newbuf[sizeof(effect_param_t) + sizeof(newdata)] = {};
|
|
effect_param_t *newparam = (effect_param_t *)(&newbuf);
|
|
newparam->psize = newPSizeInShorts * sizeof(uint16_t); // padded to 4 * sizeof(uint16_t)
|
|
newparam->vsize = newVSizeInShorts * sizeof(uint16_t);
|
|
auto newwriter = EffectParamWriter(*newparam);
|
|
EXPECT_EQ(OK, newwriter.writeToParameter(newdata, newPSizeInShorts));
|
|
EXPECT_EQ(OK, newwriter.writeToValue(
|
|
&newdata[EffectParamWrapper::padding(newPSizeInShorts)],
|
|
newVSizeInShorts));
|
|
newwriter.finishValueWrite();
|
|
|
|
EXPECT_NE(OK, writer.overwrite(newwriter.getEffectParam()));
|
|
} |