1/* 2 * Copyright 2016 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_NDEBUG 0 18#define LOG_TAG "C2Param_test" 19 20#include <gtest/gtest.h> 21 22#include <util/C2ParamUtils.h> 23#include <C2ParamDef.h> 24 25namespace android { 26 27void PrintTo(const _C2FieldId &id, ::std::ostream* os) { 28 *os << "@" << id._mOffset << "+" << id._mSize; 29} 30 31void PrintTo(const C2FieldDescriptor &fd, ::std::ostream *os) { 32 using FD=C2FieldDescriptor; 33 switch (fd.type()) { 34 case FD::INT32: *os << "i32"; break; 35 case FD::INT64: *os << "i64"; break; 36 case FD::UINT32: *os << "u32"; break; 37 case FD::UINT64: *os << "u64"; break; 38 case FD::FLOAT: *os << "float"; break; 39 case FD::STRING: *os << "char"; break; 40 case FD::BLOB: *os << "u8"; break; 41 default: 42 if (fd.type() & FD::STRUCT_FLAG) { 43 *os << "struct-" << (fd.type() & ~FD::STRUCT_FLAG); 44 } else { 45 *os << "type-" << fd.type(); 46 } 47 } 48 *os << " " << fd.name(); 49 if (fd.length() > 1) { 50 *os << "[" << fd.length() << "]"; 51 } else if (fd.length() == 0) { 52 *os << "[]"; 53 } 54 *os << " ("; 55 PrintTo(fd._mFieldId, os); 56 *os << "*" << fd.length() << ")"; 57} 58 59enum C2ParamIndexType { 60 kParamIndexNumber, 61 kParamIndexNumbers, 62 kParamIndexNumber2, 63 kParamIndexVendorStart = C2Param::BaseIndex::kVendorStart, 64 kParamIndexVendorNumbers, 65}; 66 67void ffff(int(*)(int)) {} 68 69/* ============================= STRUCT DECLARATION AND DESCRIPTION ============================= */ 70 71typedef C2FieldDescriptor FD; 72 73class C2ParamTest : public ::testing::Test { 74}; 75 76class C2ParamTest_ParamFieldList 77 : public ::testing::TestWithParam<std::initializer_list<const C2FieldDescriptor>> { 78}; 79 80enum { 81 kParamIndexSize, 82 kParamIndexTestA, 83 kParamIndexTestB, 84 kParamIndexTestFlexS32, 85 kParamIndexTestFlexEndS32, 86 kParamIndexTestFlexS64, 87 kParamIndexTestFlexEndS64, 88 kParamIndexTestFlexSize, 89 kParamIndexTestFlexEndSize, 90}; 91 92struct C2SizeStruct { 93 int32_t mNumber; 94 int32_t mHeight; 95 enum : uint32_t { baseIndex = kParamIndexSize }; // <= needed for C2FieldDescriptor 96 const static std::initializer_list<const C2FieldDescriptor> fieldList; // <= needed for C2FieldDescriptor 97 const static FD::Type TYPE = (FD::Type)(baseIndex | FD::STRUCT_FLAG); 98}; 99 100DEFINE_NO_NAMED_VALUES_FOR(C2SizeStruct) 101 102// Test 1. define a structure without any helper methods 103 104bool operator==(const C2FieldDescriptor &a, const C2FieldDescriptor &b) { 105 return a.type() == b.type() 106 && a.length() == b.length() 107 && strcmp(a.name(), b.name()) == 0 108 && a._mFieldId == b._mFieldId; 109} 110 111struct C2TestStruct_A { 112 int32_t mSigned32; 113 int64_t mSigned64[2]; 114 uint32_t mUnsigned32[1]; 115 uint64_t mUnsigned64; 116 float mFloat; 117 C2SizeStruct mSize[3]; 118 uint8_t mBlob[100]; 119 char mString[100]; 120 bool mYesNo[100]; 121 122 const static std::initializer_list<const C2FieldDescriptor> fieldList; 123 // enum : uint32_t { baseIndex = kParamIndexTest }; 124 // typedef C2TestStruct_A _type; 125} __attribute__((packed)); 126 127const std::initializer_list<const C2FieldDescriptor> C2TestStruct_A::fieldList = 128 { { FD::INT32, 1, "s32", 0, 4 }, 129 { FD::INT64, 2, "s64", 4, 8 }, 130 { FD::UINT32, 1, "u32", 20, 4 }, 131 { FD::UINT64, 1, "u64", 24, 8 }, 132 { FD::FLOAT, 1, "fp", 32, 4 }, 133 { C2SizeStruct::TYPE, 3, "size", 36, 8 }, 134 { FD::BLOB, 100, "blob", 60, 1 }, 135 { FD::STRING, 100, "str", 160, 1 }, 136 { FD::BLOB, 100, "y-n", 260, 1 } }; 137 138TEST_P(C2ParamTest_ParamFieldList, VerifyStruct) { 139 std::vector<const C2FieldDescriptor> fields = GetParam(), expected = C2TestStruct_A::fieldList; 140 141 // verify first field descriptor 142 EXPECT_EQ(FD::INT32, fields[0].type()); 143 EXPECT_STREQ("s32", fields[0].name()); 144 EXPECT_EQ(1u, fields[0].length()); 145 EXPECT_EQ(_C2FieldId(0, 4), fields[0]._mFieldId); 146 147 EXPECT_EQ(expected[0], fields[0]); 148 EXPECT_EQ(expected[1], fields[1]); 149 EXPECT_EQ(expected[2], fields[2]); 150 EXPECT_EQ(expected[3], fields[3]); 151 EXPECT_EQ(expected[4], fields[4]); 152 EXPECT_EQ(expected[5], fields[5]); 153 EXPECT_EQ(expected[6], fields[6]); 154 EXPECT_EQ(expected[7], fields[7]); 155 for (size_t i = 8; i < fields.size() && i < expected.size(); ++i) { 156 EXPECT_EQ(expected[i], fields[i]); 157 } 158} 159 160INSTANTIATE_TEST_CASE_P(InitializerList, C2ParamTest_ParamFieldList, ::testing::Values(C2TestStruct_A::fieldList)); 161 162// define fields using C2FieldDescriptor pointer constructor 163const std::initializer_list<const C2FieldDescriptor> C2TestStruct_A_FD_PTR_fieldList = 164 { C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->mSigned32, "s32"), 165 C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->mSigned64, "s64"), 166 C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->mUnsigned32, "u32"), 167 C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->mUnsigned64, "u64"), 168 C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->mFloat, "fp"), 169 C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->mSize, "size"), 170 C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->mBlob, "blob"), 171 C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->mString, "str"), 172 // C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->mYesNo, "y-n") 173 }; 174 175INSTANTIATE_TEST_CASE_P(PointerConstructor, C2ParamTest_ParamFieldList, ::testing::Values(C2TestStruct_A_FD_PTR_fieldList)); 176 177// define fields using C2FieldDescriptor member-pointer constructor 178const std::initializer_list<const C2FieldDescriptor> C2TestStruct_A_FD_MEM_PTR_fieldList = 179 { C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::mSigned32, "s32"), 180 C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::mSigned64, "s64"), 181 C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::mUnsigned32, "u32"), 182 C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::mUnsigned64, "u64"), 183 C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::mFloat, "fp"), 184 C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::mSize, "size"), 185 C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::mBlob, "blob"), 186 C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::mString, "str"), 187 // C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::mYesNo, "y-n") 188 }; 189 190INSTANTIATE_TEST_CASE_P(MemberPointerConstructor, C2ParamTest_ParamFieldList, ::testing::Values(C2TestStruct_A_FD_MEM_PTR_fieldList)); 191 192// Test 2. define a structure with two-step helper methods 193 194struct C2TestAStruct { 195 int32_t mSigned32; 196 int64_t mSigned64[2]; 197 uint32_t mUnsigned32[1]; 198 uint64_t mUnsigned64; 199 float mFloat; 200 C2SizeStruct mSize[3]; 201 uint8_t mBlob[100]; 202 char mString[100]; 203 bool mYesNo[100]; 204 205private: // test access level 206 DEFINE_C2STRUCT(TestA) 207} C2_PACK; 208 209DESCRIBE_C2STRUCT(TestA, { 210 C2FIELD(mSigned32, "s32") 211 C2FIELD(mSigned64, "s64") 212 C2FIELD(mUnsigned32, "u32") 213 C2FIELD(mUnsigned64, "u64") 214 C2FIELD(mFloat, "fp") 215 C2FIELD(mSize, "size") 216 C2FIELD(mBlob, "blob") 217 C2FIELD(mString, "str") 218 // C2FIELD(mYesNo, "y-n") 219}) // ; optional 220 221INSTANTIATE_TEST_CASE_P(DescribeStruct2Step, C2ParamTest_ParamFieldList, ::testing::Values(C2TestAStruct::fieldList)); 222 223// Test 3. define a structure with one-step helper method 224 225struct C2TestBStruct { 226 int32_t mSigned32; 227 int64_t mSigned64[2]; 228 uint32_t mUnsigned32[1]; 229 uint64_t mUnsigned64; 230 float mFloat; 231 C2SizeStruct mSize[3]; 232 uint8_t mBlob[100]; 233 char mString[100]; 234 bool mYesNo[100]; 235 236private: // test access level 237 DEFINE_AND_DESCRIBE_C2STRUCT(TestB) 238 239 C2FIELD(mSigned32, "s32") 240 C2FIELD(mSigned64, "s64") 241 C2FIELD(mUnsigned32, "u32") 242 C2FIELD(mUnsigned64, "u64") 243 C2FIELD(mFloat, "fp") 244 C2FIELD(mSize, "size") 245 C2FIELD(mBlob, "blob") 246 C2FIELD(mString, "str") 247 // C2FIELD(mYesNo, "y-n") 248}; 249 250INSTANTIATE_TEST_CASE_P(DescribeStruct1Step, C2ParamTest_ParamFieldList, ::testing::Values(C2TestBStruct::fieldList)); 251 252// Test 4. flexible members 253 254template<typename T> 255class C2ParamTest_FlexParamFieldList : public ::testing::Test { 256protected: 257 using Type=FD::Type; 258 259 // static std::initializer_list<std::initializer_list<const C2FieldDescriptor>> 260 static std::vector<std::vector<const C2FieldDescriptor>> 261 GetLists(); 262 263 constexpr static Type flexType = 264 std::is_same<T, int32_t>::value ? FD::INT32 : 265 std::is_same<T, int64_t>::value ? FD::INT64 : 266 std::is_same<T, uint32_t>::value ? FD::UINT32 : 267 std::is_same<T, uint64_t>::value ? FD::UINT64 : 268 std::is_same<T, float>::value ? FD::FLOAT : 269 std::is_same<T, uint8_t>::value ? FD::BLOB : 270 std::is_same<T, char>::value ? FD::STRING : 271 std::is_same<T, C2SizeStruct>::value ? C2SizeStruct::TYPE : (Type)0; 272 constexpr static size_t flexSize = sizeof(T); 273}; 274 275typedef ::testing::Types<int32_t, int64_t, C2SizeStruct> FlexTypes; 276TYPED_TEST_CASE(C2ParamTest_FlexParamFieldList, FlexTypes); 277 278TYPED_TEST(C2ParamTest_FlexParamFieldList, VerifyStruct) { 279 for (auto a : this->GetLists()) { 280 std::vector<const C2FieldDescriptor> fields = a; 281 if (fields.size() > 1) { 282 EXPECT_EQ(2u, fields.size()); 283 EXPECT_EQ(C2FieldDescriptor(FD::INT32, 1, "s32", 0, 4), fields[0]); 284 EXPECT_EQ(C2FieldDescriptor(this->flexType, 0, "flex", 4, this->flexSize), 285 fields[1]); 286 } else { 287 EXPECT_EQ(1u, fields.size()); 288 EXPECT_EQ(C2FieldDescriptor(this->flexType, 0, "flex", 0, this->flexSize), 289 fields[0]); 290 } 291 } 292} 293 294struct C2TestStruct_FlexS32 { 295 int32_t mFlex[]; 296 297 const static std::initializer_list<const C2FieldDescriptor> fieldList; 298 // enum : uint32_t { baseIndex = kParamIndexTestFlex, flexSize = 4 }; 299 // typedef C2TestStruct_FlexS32 _type; 300 // typedef int32_t flexType; 301}; 302 303const std::initializer_list<const C2FieldDescriptor> C2TestStruct_FlexS32::fieldList = { 304 { FD::INT32, 0, "flex", 0, 4 } 305}; 306 307struct C2TestStruct_FlexEndS32 { 308 int32_t mSigned32; 309 int32_t mFlex[]; 310 311 const static std::initializer_list<const C2FieldDescriptor> fieldList; 312 // enum : uint32_t { baseIndex = kParamIndexTestFlexEnd, flexSize = 4 }; 313 // typedef C2TestStruct_FlexEnd _type; 314 // typedef int32_t flexType; 315}; 316 317const std::initializer_list<const C2FieldDescriptor> C2TestStruct_FlexEndS32::fieldList = { 318 { FD::INT32, 1, "s32", 0, 4 }, 319 { FD::INT32, 0, "flex", 4, 4 }, 320}; 321 322const static std::initializer_list<const C2FieldDescriptor> C2TestStruct_FlexEndS32_ptr_fieldList = { 323 C2FieldDescriptor(&((C2TestStruct_FlexEndS32*)0)->mSigned32, "s32"), 324 C2FieldDescriptor(&((C2TestStruct_FlexEndS32*)0)->mFlex, "flex"), 325}; 326 327struct C2TestFlexS32Struct { 328 int32_t mFlexSigned32[]; 329private: // test access level 330 C2TestFlexS32Struct() {} 331 332 DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(TestFlexS32, mFlexSigned32) 333 C2FIELD(mFlexSigned32, "flex") 334}; 335 336struct C2TestFlexEndS32Struct { 337 int32_t mSigned32; 338 int32_t mFlexSigned32[]; 339private: // test access level 340 C2TestFlexEndS32Struct() {} 341 342 DEFINE_FLEX_C2STRUCT(TestFlexEndS32, mFlexSigned32) 343} C2_PACK; 344 345DESCRIBE_C2STRUCT(TestFlexEndS32, { 346 C2FIELD(mSigned32, "s32") 347 C2FIELD(mFlexSigned32, "flex") 348}) // ; optional 349 350template<> 351std::vector<std::vector<const C2FieldDescriptor>> 352//std::initializer_list<std::initializer_list<const C2FieldDescriptor>> 353C2ParamTest_FlexParamFieldList<int32_t>::GetLists() { 354 return { 355 C2TestStruct_FlexS32::fieldList, 356 C2TestStruct_FlexEndS32::fieldList, 357 C2TestStruct_FlexEndS32_ptr_fieldList, 358 C2TestFlexS32Struct::fieldList, 359 C2TestFlexEndS32Struct::fieldList, 360 }; 361} 362 363struct C2TestStruct_FlexS64 { 364 int64_t mFlexSigned64[]; 365 366 const static std::initializer_list<const C2FieldDescriptor> fieldList; 367 // enum : uint32_t { baseIndex = kParamIndexTestFlexS64, flexSize = 8 }; 368 // typedef C2TestStruct_FlexS64 _type; 369 // typedef int64_t flexType; 370}; 371 372const std::initializer_list<const C2FieldDescriptor> C2TestStruct_FlexS64::fieldList = { 373 { FD::INT64, 0, "flex", 0, 8 } 374}; 375 376struct C2TestStruct_FlexEndS64 { 377 int32_t mSigned32; 378 int64_t mSigned64Flex[]; 379 380 const static std::initializer_list<const C2FieldDescriptor> fieldList; 381 // enum : uint32_t { baseIndex = C2TestStruct_FlexEndS64, flexSize = 8 }; 382 // typedef C2TestStruct_FlexEndS64 _type; 383 // typedef int64_t flexType; 384}; 385 386const std::initializer_list<const C2FieldDescriptor> C2TestStruct_FlexEndS64::fieldList = { 387 { FD::INT32, 1, "s32", 0, 4 }, 388 { FD::INT64, 0, "flex", 4, 8 }, 389}; 390 391struct C2TestFlexS64Struct { 392 int64_t mFlexSigned64[]; 393 C2TestFlexS64Struct() {} 394 395 DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(TestFlexS64, mFlexSigned64) 396 C2FIELD(mFlexSigned64, "flex") 397}; 398 399struct C2TestFlexEndS64Struct { 400 int32_t mSigned32; 401 int64_t mFlexSigned64[]; 402 C2TestFlexEndS64Struct() {} 403 404 DEFINE_FLEX_C2STRUCT(TestFlexEndS64, mFlexSigned64) 405} C2_PACK; 406 407DESCRIBE_C2STRUCT(TestFlexEndS64, { 408 C2FIELD(mSigned32, "s32") 409 C2FIELD(mFlexSigned64, "flex") 410}) // ; optional 411 412template<> 413std::vector<std::vector<const C2FieldDescriptor>> 414//std::initializer_list<std::initializer_list<const C2FieldDescriptor>> 415C2ParamTest_FlexParamFieldList<int64_t>::GetLists() { 416 return { 417 C2TestStruct_FlexS64::fieldList, 418 C2TestStruct_FlexEndS64::fieldList, 419 C2TestFlexS64Struct::fieldList, 420 C2TestFlexEndS64Struct::fieldList, 421 }; 422} 423 424struct C2TestStruct_FlexSize { 425 C2SizeStruct mFlexSize[]; 426 427 const static std::initializer_list<const C2FieldDescriptor> fieldList; 428 // enum : uint32_t { baseIndex = kParamIndexTestFlexSize, flexSize = 8 }; 429 // typedef C2TestStruct_FlexSize _type; 430 // typedef C2SizeStruct flexType; 431}; 432 433const std::initializer_list<const C2FieldDescriptor> C2TestStruct_FlexSize::fieldList = { 434 { C2SizeStruct::TYPE, 0, "flex", 0, sizeof(C2SizeStruct) } 435}; 436 437struct C2TestStruct_FlexEndSize { 438 int32_t mSigned32; 439 C2SizeStruct mSizeFlex[]; 440 441 const static std::initializer_list<const C2FieldDescriptor> fieldList; 442 // enum : uint32_t { baseIndex = C2TestStruct_FlexEndSize, flexSize = 8 }; 443 // typedef C2TestStruct_FlexEndSize _type; 444 // typedef C2SizeStruct flexType; 445}; 446 447const std::initializer_list<const C2FieldDescriptor> C2TestStruct_FlexEndSize::fieldList = { 448 { FD::INT32, 1, "s32", 0, 4 }, 449 { C2SizeStruct::TYPE, 0, "flex", 4, sizeof(C2SizeStruct) }, 450}; 451 452struct C2TestFlexSizeStruct { 453 C2SizeStruct mFlexSize[]; 454 C2TestFlexSizeStruct() {} 455 456 DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(TestFlexSize, mFlexSize) 457 C2FIELD(mFlexSize, "flex") 458}; 459 460struct C2TestFlexEndSizeStruct { 461 int32_t mSigned32; 462 C2SizeStruct mFlexSize[]; 463 C2TestFlexEndSizeStruct() {} 464 465 DEFINE_FLEX_C2STRUCT(TestFlexEndSize, mFlexSize) 466} C2_PACK; 467 468DESCRIBE_C2STRUCT(TestFlexEndSize, { 469 C2FIELD(mSigned32, "s32") 470 C2FIELD(mFlexSize, "flex") 471}) // ; optional 472 473template<> 474std::vector<std::vector<const C2FieldDescriptor>> 475//std::initializer_list<std::initializer_list<const C2FieldDescriptor>> 476C2ParamTest_FlexParamFieldList<C2SizeStruct>::GetLists() { 477 return { 478 C2TestStruct_FlexSize::fieldList, 479 C2TestStruct_FlexEndSize::fieldList, 480 C2TestFlexSizeStruct::fieldList, 481 C2TestFlexEndSizeStruct::fieldList, 482 }; 483} 484 485TEST_F(C2ParamTest, FieldId) { 486 // pointer constructor 487 EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId(&((C2TestStruct_A*)0)->mSigned32)); 488 EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId(&((C2TestStruct_A*)0)->mSigned64)); 489 EXPECT_EQ(_C2FieldId(20, 4), _C2FieldId(&((C2TestStruct_A*)0)->mUnsigned32)); 490 EXPECT_EQ(_C2FieldId(24, 8), _C2FieldId(&((C2TestStruct_A*)0)->mUnsigned64)); 491 EXPECT_EQ(_C2FieldId(32, 4), _C2FieldId(&((C2TestStruct_A*)0)->mFloat)); 492 EXPECT_EQ(_C2FieldId(36, 8), _C2FieldId(&((C2TestStruct_A*)0)->mSize)); 493 EXPECT_EQ(_C2FieldId(60, 1), _C2FieldId(&((C2TestStruct_A*)0)->mBlob)); 494 EXPECT_EQ(_C2FieldId(160, 1), _C2FieldId(&((C2TestStruct_A*)0)->mString)); 495 EXPECT_EQ(_C2FieldId(260, 1), _C2FieldId(&((C2TestStruct_A*)0)->mYesNo)); 496 497 EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId(&((C2TestFlexEndSizeStruct*)0)->mSigned32)); 498 EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId(&((C2TestFlexEndSizeStruct*)0)->mFlexSize)); 499 500 // member pointer constructor 501 EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::mSigned32)); 502 EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::mSigned64)); 503 EXPECT_EQ(_C2FieldId(20, 4), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::mUnsigned32)); 504 EXPECT_EQ(_C2FieldId(24, 8), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::mUnsigned64)); 505 EXPECT_EQ(_C2FieldId(32, 4), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::mFloat)); 506 EXPECT_EQ(_C2FieldId(36, 8), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::mSize)); 507 EXPECT_EQ(_C2FieldId(60, 1), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::mBlob)); 508 EXPECT_EQ(_C2FieldId(160, 1), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::mString)); 509 EXPECT_EQ(_C2FieldId(260, 1), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::mYesNo)); 510 511 EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId((C2TestFlexEndSizeStruct*)0, &C2TestFlexEndSizeStruct::mSigned32)); 512 EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId((C2TestFlexEndSizeStruct*)0, &C2TestFlexEndSizeStruct::mFlexSize)); 513 514 // member pointer sans type pointer 515 EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId(&C2TestStruct_A::mSigned32)); 516 EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId(&C2TestStruct_A::mSigned64)); 517 EXPECT_EQ(_C2FieldId(20, 4), _C2FieldId(&C2TestStruct_A::mUnsigned32)); 518 EXPECT_EQ(_C2FieldId(24, 8), _C2FieldId(&C2TestStruct_A::mUnsigned64)); 519 EXPECT_EQ(_C2FieldId(32, 4), _C2FieldId(&C2TestStruct_A::mFloat)); 520 EXPECT_EQ(_C2FieldId(36, 8), _C2FieldId(&C2TestStruct_A::mSize)); 521 EXPECT_EQ(_C2FieldId(60, 1), _C2FieldId(&C2TestStruct_A::mBlob)); 522 EXPECT_EQ(_C2FieldId(160, 1), _C2FieldId(&C2TestStruct_A::mString)); 523 EXPECT_EQ(_C2FieldId(260, 1), _C2FieldId(&C2TestStruct_A::mYesNo)); 524 525 EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId(&C2TestFlexEndSizeStruct::mSigned32)); 526 EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId(&C2TestFlexEndSizeStruct::mFlexSize)); 527 528 typedef C2GlobalParam<C2Info, C2TestAStruct> C2TestAInfo; 529 typedef C2GlobalParam<C2Info, C2TestFlexEndSizeStruct> C2TestFlexEndSizeInfo; 530 531 // pointer constructor in C2Param 532 EXPECT_EQ(_C2FieldId(8, 4), _C2FieldId(&((C2TestAInfo*)0)->mSigned32)); 533 EXPECT_EQ(_C2FieldId(12, 8), _C2FieldId(&((C2TestAInfo*)0)->mSigned64)); 534 EXPECT_EQ(_C2FieldId(28, 4), _C2FieldId(&((C2TestAInfo*)0)->mUnsigned32)); 535 EXPECT_EQ(_C2FieldId(32, 8), _C2FieldId(&((C2TestAInfo*)0)->mUnsigned64)); 536 EXPECT_EQ(_C2FieldId(40, 4), _C2FieldId(&((C2TestAInfo*)0)->mFloat)); 537 EXPECT_EQ(_C2FieldId(44, 8), _C2FieldId(&((C2TestAInfo*)0)->mSize)); 538 EXPECT_EQ(_C2FieldId(68, 1), _C2FieldId(&((C2TestAInfo*)0)->mBlob)); 539 EXPECT_EQ(_C2FieldId(168, 1), _C2FieldId(&((C2TestAInfo*)0)->mString)); 540 EXPECT_EQ(_C2FieldId(268, 1), _C2FieldId(&((C2TestAInfo*)0)->mYesNo)); 541 542 EXPECT_EQ(_C2FieldId(8, 4), _C2FieldId(&((C2TestFlexEndSizeInfo*)0)->m.mSigned32)); 543 EXPECT_EQ(_C2FieldId(12, 8), _C2FieldId(&((C2TestFlexEndSizeInfo*)0)->m.mFlexSize)); 544 545 // member pointer in C2Param 546 EXPECT_EQ(_C2FieldId(8, 4), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::mSigned32)); 547 EXPECT_EQ(_C2FieldId(12, 8), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::mSigned64)); 548 EXPECT_EQ(_C2FieldId(28, 4), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::mUnsigned32)); 549 EXPECT_EQ(_C2FieldId(32, 8), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::mUnsigned64)); 550 EXPECT_EQ(_C2FieldId(40, 4), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::mFloat)); 551 EXPECT_EQ(_C2FieldId(44, 8), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::mSize)); 552 EXPECT_EQ(_C2FieldId(68, 1), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::mBlob)); 553 EXPECT_EQ(_C2FieldId(168, 1), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::mString)); 554 EXPECT_EQ(_C2FieldId(268, 1), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::mYesNo)); 555 556 // NOTE: cannot use a member pointer for flex params due to introduction of 'm' 557 // EXPECT_EQ(_C2FieldId(8, 4), _C2FieldId(&C2TestFlexEndSizeInfo::m.mSigned32)); 558 // EXPECT_EQ(_C2FieldId(12, 8), _C2FieldId(&C2TestFlexEndSizeInfo::m.mFlexSize)); 559 560 561 562} 563 564struct S32 { 565 template<typename T, class B=typename std::remove_extent<T>::type> 566 inline S32(const T*) { 567 static_assert(!std::is_array<T>::value, "should not be an array"); 568 static_assert(std::is_same<B, int32_t>::value, "should be int32_t"); 569 } 570}; 571 572struct FLX { 573 template<typename U, typename T, class B=typename std::remove_extent<T>::type> 574 inline FLX(const T*, const U*) { 575 static_assert(std::is_array<T>::value, "should be an array"); 576 static_assert(std::extent<T>::value == 0, "should be an array of 0 extent"); 577 static_assert(std::is_same<B, U>::value, "should be type U"); 578 } 579}; 580 581struct MP { 582 template<typename U, typename T, typename ExpectedU, typename UnexpectedU> 583 inline MP(T U::*, const ExpectedU*, const UnexpectedU*) { 584 static_assert(!std::is_same<U, UnexpectedU>::value, "should not be member pointer of the base type"); 585 static_assert(std::is_same<U, ExpectedU>::value, "should be member pointer of the derived type"); 586 } 587 588 template<typename U, typename T, typename B, typename D> 589 inline MP(T D::*, const D*) { } 590}; 591 592void compiledStatic_arrayTypePropagationTest() { 593 (void)S32(&((C2TestFlexEndS32Struct *)0)->mSigned32); 594 (void)FLX(&((C2TestFlexEndS32Struct *)0)->mFlexSigned32, (int32_t*)0); 595 (void)FLX(&((C2TestFlexS32Struct *)0)->mFlexSigned32, (int32_t*)0); 596 597 typedef C2GlobalParam<C2Info, C2TestAStruct> C2TestAInfo; 598 599 // TRICKY: &derivedClass::baseMember has type of baseClass::* 600 static_assert(std::is_same<decltype(&C2TestAInfo::mSigned32), int32_t C2TestAStruct::*>::value, 601 "base member pointer should have base class in type"); 602 603 // therefore, member pointer expands to baseClass::* in templates 604 (void)MP(&C2TestAInfo::mSigned32, 605 (C2TestAStruct*)0 /* expected */, (C2TestAInfo*)0 /* unexpected */); 606 // but can be cast to derivedClass::* 607 (void)MP((int32_t C2TestAInfo::*)&C2TestAInfo::mSigned32, 608 (C2TestAInfo*)0 /* expected */, (C2TestAStruct*)0 /* unexpected */); 609 610 // TRICKY: baseClass::* does not autoconvert to derivedClass::* even in templates 611 // (void)MP(&C2TestAInfo::mSigned32, (C2TestAInfo*)0); 612} 613 614TEST_F(C2ParamTest, MemberPointerCast) { 615 typedef C2GlobalParam<C2Info, C2TestAStruct> C2TestAInfo; 616 617 static_assert(offsetof(C2TestAInfo, mSigned32) == 8, "offset should be 8"); 618 constexpr int32_t C2TestAStruct::* s32ptr = &C2TestAInfo::mSigned32; 619 constexpr int32_t C2TestAInfo::* s32ptr_derived = (int32_t C2TestAStruct::*)&C2TestAInfo::mSigned32; 620 constexpr int32_t C2TestAInfo::* s32ptr_cast2derived = (int32_t C2TestAInfo::*)s32ptr; 621 C2TestAInfo *info = (C2TestAInfo *)256; 622 C2TestAStruct *strukt = (C2TestAStruct *)info; 623 int32_t *info_s32_derived = &(info->*s32ptr_derived); 624 int32_t *info_s32_cast2derived = &(info->*s32ptr_cast2derived); 625 int32_t *info_s32 = &(info->*s32ptr); 626 int32_t *strukt_s32 = &(strukt->*s32ptr); 627 628 EXPECT_EQ(256u, (uintptr_t)info); 629 EXPECT_EQ(264u, (uintptr_t)strukt); 630 EXPECT_EQ(264u, (uintptr_t)info_s32_derived); 631 EXPECT_EQ(264u, (uintptr_t)info_s32_cast2derived); 632 EXPECT_EQ(264u, (uintptr_t)info_s32); 633 EXPECT_EQ(264u, (uintptr_t)strukt_s32); 634 635 typedef C2GlobalParam<C2Info, C2TestFlexEndSizeStruct> C2TestFlexEndSizeInfo; 636 static_assert(offsetof(C2TestFlexEndSizeInfo, m.mSigned32) == 8, "offset should be 8"); 637 static_assert(offsetof(C2TestFlexEndSizeInfo, m.mFlexSize) == 12, "offset should be 12"); 638} 639 640/* ===================================== PARAM USAGE TESTS ===================================== */ 641 642struct C2NumberStruct { 643 int32_t mNumber; 644 C2NumberStruct() {} 645 C2NumberStruct(int32_t _number) : mNumber(_number) {} 646 647 DEFINE_AND_DESCRIBE_C2STRUCT(Number) 648 C2FIELD(mNumber, "number") 649}; 650 651struct C2NumbersStruct { 652 int32_t mNumbers[]; 653 C2NumbersStruct() {} 654 655 DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(Numbers, mNumbers) 656 C2FIELD(mNumbers, "numbers") 657}; 658static_assert(sizeof(C2NumbersStruct) == 0, "C2NumbersStruct has incorrect size"); 659 660typedef C2GlobalParam<C2Tuning, C2NumberStruct> C2NumberTuning; 661typedef C2PortParam<C2Tuning, C2NumberStruct> C2NumberPortTuning; 662typedef C2StreamParam<C2Tuning, C2NumberStruct> C2NumberStreamTuning; 663 664typedef C2GlobalParam<C2Tuning, C2NumbersStruct> C2NumbersTuning; 665typedef C2PortParam<C2Tuning, C2NumbersStruct> C2NumbersPortTuning; 666typedef C2StreamParam<C2Tuning, C2NumbersStruct> C2NumbersStreamTuning; 667 668// 669#if 0 670 671void test() { 672 C2NumberStruct s(10); 673 (void)C2NumberStruct::fieldList; 674}; 675 676typedef C2StreamParam<C2Tuning, C2Int64Value, kParamIndexNumberB> C2NumberConfig4; 677typedef C2PortParam<C2Tuning, C2Int32Value, kParamIndexNumber> C2NumberConfig3; 678typedef C2GlobalParam<C2Tuning, C2StringValue, kParamIndexNumber> C2VideoNameConfig; 679 680void test3() { 681 C2NumberConfig3 s(10); 682 s.mValue = 11; 683 s = 12; 684 (void)C2NumberConfig3::fieldList; 685 std::shared_ptr<C2VideoNameConfig> n = C2VideoNameConfig::alloc_shared(25); 686 strcpy(n->m.mValue, "lajos"); 687 C2NumberConfig4 t(false, 0, 11); 688 t.mValue = 15; 689}; 690 691struct C2NumbersStruct { 692 int32_t mNumbers[]; 693 enum { baseIndex = kParamIndexNumber }; 694 const static std::initializer_list<const C2FieldDescriptor> fieldList; 695 C2NumbersStruct() {} 696 697 FLEX(C2NumbersStruct, mNumbers); 698}; 699 700static_assert(sizeof(C2NumbersStruct) == 0, "yes"); 701 702 703typedef C2GlobalParam<C2Info, C2NumbersStruct> C2NumbersInfo; 704 705const std::initializer_list<const C2FieldDescriptor> C2NumbersStruct::fieldList = 706// { { FD::INT32, 0, "widths" } }; 707 { C2FieldDescriptor(&((C2NumbersStruct*)(nullptr))->mNumbers, "number") }; 708 709typedef C2PortParam<C2Tuning, C2NumberStruct> C2NumberConfig; 710 711std::list<const C2FieldDescriptor> myList = C2NumberConfig::fieldList; 712 713 std::unique_ptr<android::C2ParamDescriptor> __test_describe(uint32_t paramType) { 714 std::list<const C2FieldDescriptor> fields = describeC2Params<C2NumberConfig>(); 715 716 auto widths = C2NumbersInfo::alloc_shared(5); 717 widths->flexCount(); 718 widths->m.mNumbers[4] = 1; 719 720 test(); 721 test3(); 722 723 C2NumberConfig outputWidth(false, 123); 724 725 C2Param::Index index(paramType); 726 switch (paramType) { 727 case C2NumberConfig::baseIndex: 728 return std::unique_ptr<C2ParamDescriptor>(new C2ParamDescriptor{ 729 true /* isRequired */, 730 "number", 731 index, 732 }); 733 } 734 return nullptr; 735 } 736 737 738} // namespace android 739 740#endif 741// 742 743template<typename T> 744bool canSetPort(T &o, bool output) { return o.setPort(output); } 745bool canSetPort(...) { return false; } 746 747template<typename S, typename=decltype(((S*)0)->setPort(true))> 748static std::true_type _canCallSetPort(int); 749template<typename> 750static std::false_type _canCallSetPort(...); 751#define canCallSetPort(x) decltype(_canCallSetPort<std::remove_reference<decltype(x)>::type>(0))::value 752 753/* ======================================= STATIC TESTS ======================================= */ 754 755static_assert(_C2Comparable<int>::value, "int is not comparable"); 756static_assert(!_C2Comparable<void>::value, "void is comparable"); 757 758struct C2_HIDE _test0 { 759 bool operator==(const _test0&); 760 bool operator!=(const _test0&); 761}; 762struct C2_HIDE _test1 { 763 bool operator==(const _test1&); 764}; 765struct C2_HIDE _test2 { 766 bool operator!=(const _test2&); 767}; 768static_assert(_C2Comparable<_test0>::value, "class with == and != is not comparable"); 769static_assert(_C2Comparable<_test1>::value, "class with == is not comparable"); 770static_assert(_C2Comparable<_test2>::value, "class with != is not comparable"); 771 772/* ======================================= C2PARAM TESTS ======================================= */ 773 774struct _C2ParamInspector { 775 static void StaticTest(); 776 static void StaticFlexTest(); 777}; 778 779// TEST_F(_C2ParamInspector, StaticTest) { 780void _C2ParamInspector::StaticTest() { 781 typedef C2Param::Index I; 782 783 // C2NumberStruct: baseIndex = kIndex (args) 784 static_assert(C2NumberStruct::baseIndex == kParamIndexNumber, "bad index"); 785 static_assert(sizeof(C2NumberStruct) == 4, "bad size"); 786 787 // C2NumberTuning: kIndex | tun | global (args) 788 static_assert(C2NumberTuning::baseIndex == kParamIndexNumber, "bad index"); 789 static_assert(C2NumberTuning::typeIndex == (kParamIndexNumber | I::kTypeTuning | I::kDirGlobal), "bad index"); 790 static_assert(sizeof(C2NumberTuning) == 12, "bad size"); 791 792 static_assert(offsetof(C2NumberTuning, _mSize) == 0, "bad size"); 793 static_assert(offsetof(C2NumberTuning, _mIndex) == 4, "bad offset"); 794 static_assert(offsetof(C2NumberTuning, mNumber) == 8, "bad offset"); 795 796 // C2NumberPortTuning: kIndex | tun | port (bool, args) 797 static_assert(sizeof(C2NumberPortTuning) == 12, "bad size"); 798 // C2NumberPortTuning::input: kIndex | tun | port | input (args) 799 // C2NumberPortTuning::output: kIndex | tun | port | output (args) 800 static_assert(C2NumberPortTuning::input::baseIndex == 801 kParamIndexNumber, "bad index"); 802 static_assert(C2NumberPortTuning::input::typeIndex == 803 (kParamIndexNumber | I::kTypeTuning | I::kDirInput), "bad index"); 804 static_assert(C2NumberPortTuning::output::baseIndex == 805 kParamIndexNumber, "bad index"); 806 static_assert(C2NumberPortTuning::output::typeIndex == 807 (kParamIndexNumber | I::kTypeTuning | I::kDirOutput), "bad index"); 808 static_assert(sizeof(C2NumberPortTuning::input) == 12, "bad size"); 809 static_assert(sizeof(C2NumberPortTuning::output) == 12, "bad size"); 810 static_assert(offsetof(C2NumberPortTuning::input, _mSize) == 0, "bad size"); 811 static_assert(offsetof(C2NumberPortTuning::input, _mIndex) == 4, "bad offset"); 812 static_assert(offsetof(C2NumberPortTuning::input, mNumber) == 8, "bad offset"); 813 static_assert(offsetof(C2NumberPortTuning::output, _mSize) == 0, "bad size"); 814 static_assert(offsetof(C2NumberPortTuning::output, _mIndex) == 4, "bad offset"); 815 static_assert(offsetof(C2NumberPortTuning::output, mNumber) == 8, "bad offset"); 816 817 // C2NumberStreamTuning: kIndex | tun | str (bool, uint, args) 818 static_assert(sizeof(C2NumberStreamTuning) == 12u, "bad size"); 819 // C2NumberStreamTuning::input kIndex | tun | str | input (int, args) 820 // C2NumberStreamTuning::output kIx | tun | str | output (int, args) 821 static_assert(C2NumberStreamTuning::input::baseIndex == 822 kParamIndexNumber, "bad index"); 823 static_assert(C2NumberStreamTuning::input::typeIndex == 824 (kParamIndexNumber | I::kTypeTuning | I::kDirInput | I::kStreamFlag), "bad index"); 825 static_assert(C2NumberStreamTuning::output::baseIndex == 826 kParamIndexNumber, "bad index"); 827 static_assert(C2NumberStreamTuning::output::typeIndex == 828 (kParamIndexNumber | I::kTypeTuning | I::kDirOutput | I::kStreamFlag), "bad index"); 829 static_assert(sizeof(C2NumberStreamTuning::input) == 12u, "bad size"); 830 static_assert(sizeof(C2NumberStreamTuning::output) == 12u, "bad size"); 831 static_assert(offsetof(C2NumberStreamTuning::input, _mSize) == 0, "bad size"); 832 static_assert(offsetof(C2NumberStreamTuning::input, _mIndex) == 4, "bad offset"); 833 static_assert(offsetof(C2NumberStreamTuning::input, mNumber) == 8, "bad offset"); 834 static_assert(offsetof(C2NumberStreamTuning::output, _mSize) == 0, "bad size"); 835 static_assert(offsetof(C2NumberStreamTuning::output, _mIndex) == 4, "bad offset"); 836 static_assert(offsetof(C2NumberStreamTuning::output, mNumber) == 8, "bad offset"); 837} 838 839void _C2ParamInspector::StaticFlexTest() { 840 typedef C2Param::Index I; 841 842 // C2NumbersStruct: baseIndex = kIndex (args) 843 static_assert(C2NumbersStruct::baseIndex == (I::kFlexibleFlag | kParamIndexNumbers), "bad index"); 844 static_assert(sizeof(C2NumbersStruct) == 0, "bad size"); 845 846 // C2NumbersTuning: kIndex | tun | global (args) 847 static_assert(C2NumbersTuning::baseIndex == (I::kFlexibleFlag | kParamIndexNumbers), "bad index"); 848 static_assert(C2NumbersTuning::typeIndex == (I::kFlexibleFlag | kParamIndexNumbers | I::kTypeTuning | I::kDirGlobal), "bad index"); 849 static_assert(sizeof(C2NumbersTuning) == 8, "bad size"); 850 851 static_assert(offsetof(C2NumbersTuning, _mSize) == 0, "bad size"); 852 static_assert(offsetof(C2NumbersTuning, _mIndex) == 4, "bad offset"); 853 static_assert(offsetof(C2NumbersTuning, m.mNumbers) == 8, "bad offset"); 854 855 // C2NumbersPortTuning: kIndex | tun | port (bool, args) 856 static_assert(sizeof(C2NumbersPortTuning) == 8, "bad size"); 857 // C2NumbersPortTuning::input: kIndex | tun | port | input (args) 858 // C2NumbersPortTuning::output: kIndex | tun | port | output (args) 859 static_assert(C2NumbersPortTuning::input::baseIndex == 860 (I::kFlexibleFlag | kParamIndexNumbers), "bad index"); 861 static_assert(C2NumbersPortTuning::input::typeIndex == 862 (I::kFlexibleFlag | kParamIndexNumbers | I::kTypeTuning | I::kDirInput), "bad index"); 863 static_assert(C2NumbersPortTuning::output::baseIndex == 864 (I::kFlexibleFlag | kParamIndexNumbers), "bad index"); 865 static_assert(C2NumbersPortTuning::output::typeIndex == 866 (I::kFlexibleFlag | kParamIndexNumbers | I::kTypeTuning | I::kDirOutput), "bad index"); 867 static_assert(sizeof(C2NumbersPortTuning::input) == 8, "bad size"); 868 static_assert(sizeof(C2NumbersPortTuning::output) == 8, "bad size"); 869 static_assert(offsetof(C2NumbersPortTuning::input, _mSize) == 0, "bad size"); 870 static_assert(offsetof(C2NumbersPortTuning::input, _mIndex) == 4, "bad offset"); 871 static_assert(offsetof(C2NumbersPortTuning::input, m.mNumbers) == 8, "bad offset"); 872 static_assert(offsetof(C2NumbersPortTuning::output, _mSize) == 0, "bad size"); 873 static_assert(offsetof(C2NumbersPortTuning::output, _mIndex) == 4, "bad offset"); 874 static_assert(offsetof(C2NumbersPortTuning::output, m.mNumbers) == 8, "bad offset"); 875 876 // C2NumbersStreamTuning: kIndex | tun | str (bool, uint, args) 877 static_assert(sizeof(C2NumbersStreamTuning) == 8, "bad size"); 878 // C2NumbersStreamTuning::input kIndex | tun | str | input (int, args) 879 // C2NumbersStreamTuning::output kIx | tun | str | output (int, args) 880 static_assert(C2NumbersStreamTuning::input::baseIndex == 881 (I::kFlexibleFlag | kParamIndexNumbers), "bad index"); 882 static_assert(C2NumbersStreamTuning::input::typeIndex == 883 (I::kFlexibleFlag | kParamIndexNumbers | I::kTypeTuning | I::kDirInput | I::kStreamFlag), "bad index"); 884 static_assert(C2NumbersStreamTuning::output::baseIndex == 885 (I::kFlexibleFlag | kParamIndexNumbers), "bad index"); 886 static_assert(C2NumbersStreamTuning::output::typeIndex == 887 (I::kFlexibleFlag | kParamIndexNumbers | I::kTypeTuning | I::kDirOutput | I::kStreamFlag), "bad index"); 888 static_assert(sizeof(C2NumbersStreamTuning::input) == 8, "bad size"); 889 static_assert(sizeof(C2NumbersStreamTuning::output) == 8, "bad size"); 890 static_assert(offsetof(C2NumbersStreamTuning::input, _mSize) == 0, "bad size"); 891 static_assert(offsetof(C2NumbersStreamTuning::input, _mIndex) == 4, "bad offset"); 892 static_assert(offsetof(C2NumbersStreamTuning::input, m.mNumbers) == 8, "bad offset"); 893 static_assert(offsetof(C2NumbersStreamTuning::output, _mSize) == 0, "bad size"); 894 static_assert(offsetof(C2NumbersStreamTuning::output, _mIndex) == 4, "bad offset"); 895 static_assert(offsetof(C2NumbersStreamTuning::output, m.mNumbers) == 8, "bad offset"); 896} 897 898TEST_F(C2ParamTest, ParamOpsTest) { 899 const C2NumberStruct str(100); 900 C2NumberStruct bstr; 901 902 { 903 EXPECT_EQ(100, str.mNumber); 904 bstr.mNumber = 100; 905 906 C2Param::BaseIndex index = C2NumberStruct::baseIndex; 907 EXPECT_FALSE(index.isVendor()); 908 EXPECT_FALSE(index.isFlexible()); 909 EXPECT_EQ(index.baseIndex(), kParamIndexNumber); 910 EXPECT_EQ(index.paramIndex(), kParamIndexNumber); 911 } 912 913 const C2NumberTuning tun(100); 914 C2NumberTuning btun; 915 916 { 917 // flags & invariables 918 for (const auto &p : { tun, btun }) { 919 EXPECT_TRUE((bool)p); 920 EXPECT_FALSE(!p); 921 EXPECT_EQ(12u, p.size()); 922 923 EXPECT_FALSE(p.isVendor()); 924 EXPECT_FALSE(p.isFlexible()); 925 EXPECT_TRUE(p.isGlobal()); 926 EXPECT_FALSE(p.forInput()); 927 EXPECT_FALSE(p.forOutput()); 928 EXPECT_FALSE(p.forStream()); 929 EXPECT_FALSE(p.forPort()); 930 } 931 932 // value 933 EXPECT_EQ(100, tun.mNumber); 934 EXPECT_EQ(0, btun.mNumber); 935 EXPECT_FALSE(tun == btun); 936 EXPECT_FALSE(tun.operator==(btun)); 937 EXPECT_TRUE(tun != btun); 938 EXPECT_TRUE(tun.operator!=(btun)); 939 btun.mNumber = 100; 940 EXPECT_EQ(tun, btun); 941 942 // index 943 EXPECT_EQ(C2Param::Type(tun.type()).baseIndex(), C2NumberStruct::baseIndex); 944 EXPECT_EQ(C2Param::Type(tun.type()).paramIndex(), kParamIndexNumber); 945 EXPECT_EQ(tun.type(), C2NumberTuning::typeIndex); 946 EXPECT_EQ(tun.stream(), ~0u); 947 948 C2Param::BaseIndex index = C2NumberTuning::baseIndex; 949 EXPECT_FALSE(index.isVendor()); 950 EXPECT_FALSE(index.isFlexible()); 951 EXPECT_EQ(index.baseIndex(), kParamIndexNumber); 952 EXPECT_EQ(index.paramIndex(), kParamIndexNumber); 953 954 C2Param::Type type = C2NumberTuning::typeIndex; 955 EXPECT_FALSE(type.isVendor()); 956 EXPECT_FALSE(type.isFlexible()); 957 EXPECT_TRUE(type.isGlobal()); 958 EXPECT_FALSE(type.forInput()); 959 EXPECT_FALSE(type.forOutput()); 960 EXPECT_FALSE(type.forStream()); 961 EXPECT_FALSE(type.forPort()); 962 963 EXPECT_EQ(C2NumberTuning::From(nullptr), nullptr); 964 EXPECT_EQ(C2NumberTuning::From(&tun), &tun); 965 EXPECT_EQ(C2NumberPortTuning::From(&tun), nullptr); 966 EXPECT_EQ(C2NumberPortTuning::input::From(&tun), nullptr); 967 EXPECT_EQ(C2NumberPortTuning::output::From(&tun), nullptr); 968 EXPECT_EQ(C2NumberStreamTuning::From(&tun), nullptr); 969 EXPECT_EQ(C2NumberStreamTuning::input::From(&tun), nullptr); 970 EXPECT_EQ(C2NumberStreamTuning::output::From(&tun), nullptr); 971 } 972 973 const C2NumberPortTuning outp1(true, 100), inp1(false, 100); 974 C2NumberPortTuning boutp1, binp1, binp3(false, 100); 975 const C2NumberPortTuning::input inp2(100); 976 C2NumberPortTuning::input binp2; 977 const C2NumberPortTuning::output outp2(100); 978 C2NumberPortTuning::output boutp2; 979 980 { 981 static_assert(canCallSetPort(binp3), "should be able to"); 982 static_assert(canCallSetPort(binp1), "should be able to"); 983 static_assert(!canCallSetPort(inp1), "should not be able to (const)"); 984 static_assert(!canCallSetPort(inp2), "should not be able to (const & type)"); 985 static_assert(!canCallSetPort(binp2), "should not be able to (type)"); 986 987 // flags & invariables 988 for (const auto &p : { outp1, inp1, boutp1 }) { 989 EXPECT_EQ(12u, p.size()); 990 EXPECT_FALSE(p.isVendor()); 991 EXPECT_FALSE(p.isFlexible()); 992 EXPECT_FALSE(p.isGlobal()); 993 EXPECT_FALSE(p.forStream()); 994 EXPECT_TRUE(p.forPort()); 995 } 996 for (const auto &p : { inp2, binp2 }) { 997 EXPECT_EQ(12u, p.size()); 998 EXPECT_FALSE(p.isVendor()); 999 EXPECT_FALSE(p.isFlexible()); 1000 EXPECT_FALSE(p.isGlobal()); 1001 EXPECT_FALSE(p.forStream()); 1002 EXPECT_TRUE(p.forPort()); 1003 } 1004 for (const auto &p : { outp2, boutp2 }) { 1005 EXPECT_EQ(12u, p.size()); 1006 EXPECT_FALSE(p.isVendor()); 1007 EXPECT_FALSE(p.isFlexible()); 1008 EXPECT_FALSE(p.isGlobal()); 1009 EXPECT_FALSE(p.forStream()); 1010 EXPECT_TRUE(p.forPort()); 1011 } 1012 1013 // port specific flags & invariables 1014 EXPECT_FALSE(outp1.forInput()); 1015 EXPECT_TRUE(outp1.forOutput()); 1016 1017 EXPECT_TRUE(inp1.forInput()); 1018 EXPECT_FALSE(inp1.forOutput()); 1019 1020 for (const auto &p : { outp1, inp1 }) { 1021 EXPECT_TRUE((bool)p); 1022 EXPECT_FALSE(!p); 1023 EXPECT_EQ(100, p.mNumber); 1024 } 1025 for (const auto &p : { outp2, boutp2 }) { 1026 EXPECT_TRUE((bool)p); 1027 EXPECT_FALSE(!p); 1028 1029 EXPECT_FALSE(p.forInput()); 1030 EXPECT_TRUE(p.forOutput()); 1031 } 1032 for (const auto &p : { inp2, binp2 }) { 1033 EXPECT_TRUE((bool)p); 1034 EXPECT_FALSE(!p); 1035 1036 EXPECT_TRUE(p.forInput()); 1037 EXPECT_FALSE(p.forOutput()); 1038 } 1039 for (const auto &p : { boutp1 } ) { 1040 EXPECT_FALSE((bool)p); 1041 EXPECT_TRUE(!p); 1042 1043 EXPECT_FALSE(p.forInput()); 1044 EXPECT_FALSE(p.forOutput()); 1045 EXPECT_EQ(0, p.mNumber); 1046 } 1047 1048 // values 1049 EXPECT_EQ(100, inp2.mNumber); 1050 EXPECT_EQ(100, outp2.mNumber); 1051 EXPECT_EQ(0, binp1.mNumber); 1052 EXPECT_EQ(0, binp2.mNumber); 1053 EXPECT_EQ(0, boutp1.mNumber); 1054 EXPECT_EQ(0, boutp2.mNumber); 1055 1056 EXPECT_TRUE(inp1 != outp1); 1057 EXPECT_TRUE(inp1 == inp2); 1058 EXPECT_TRUE(outp1 == outp2); 1059 EXPECT_TRUE(binp1 == boutp1); 1060 EXPECT_TRUE(binp2 != boutp2); 1061 1062 EXPECT_TRUE(inp1 != binp1); 1063 binp1.mNumber = 100; 1064 EXPECT_TRUE(inp1 != binp1); 1065 binp1.setPort(false /* output */); 1066 EXPECT_TRUE((bool)binp1); 1067 EXPECT_FALSE(!binp1); 1068 EXPECT_TRUE(inp1 == binp1); 1069 1070 EXPECT_TRUE(inp2 != binp2); 1071 binp2.mNumber = 100; 1072 EXPECT_TRUE(inp2 == binp2); 1073 1074 binp1.setPort(true /* output */); 1075 EXPECT_TRUE(outp1 == binp1); 1076 1077 EXPECT_TRUE(outp1 != boutp1); 1078 boutp1.mNumber = 100; 1079 EXPECT_TRUE(outp1 != boutp1); 1080 boutp1.setPort(true /* output */); 1081 EXPECT_TRUE((bool)boutp1); 1082 EXPECT_FALSE(!boutp1); 1083 EXPECT_TRUE(outp1 == boutp1); 1084 1085 EXPECT_TRUE(outp2 != boutp2); 1086 boutp2.mNumber = 100; 1087 EXPECT_TRUE(outp2 == boutp2); 1088 1089 boutp1.setPort(false /* output */); 1090 EXPECT_TRUE(inp1 == boutp1); 1091 1092 // index 1093 EXPECT_EQ(C2Param::Type(inp1.type()).baseIndex(), C2NumberStruct::baseIndex); 1094 EXPECT_EQ(C2Param::Type(inp1.type()).paramIndex(), kParamIndexNumber); 1095 EXPECT_EQ(inp1.type(), C2NumberPortTuning::input::typeIndex); 1096 EXPECT_EQ(inp1.stream(), ~0u); 1097 1098 EXPECT_EQ(C2Param::Type(inp2.type()).baseIndex(), C2NumberStruct::baseIndex); 1099 EXPECT_EQ(C2Param::Type(inp2.type()).paramIndex(), kParamIndexNumber); 1100 EXPECT_EQ(inp2.type(), C2NumberPortTuning::input::typeIndex); 1101 EXPECT_EQ(inp2.stream(), ~0u); 1102 1103 EXPECT_EQ(C2Param::Type(outp1.type()).baseIndex(), C2NumberStruct::baseIndex); 1104 EXPECT_EQ(C2Param::Type(outp1.type()).paramIndex(), kParamIndexNumber); 1105 EXPECT_EQ(outp1.type(), C2NumberPortTuning::output::typeIndex); 1106 EXPECT_EQ(outp1.stream(), ~0u); 1107 1108 EXPECT_EQ(C2Param::Type(outp2.type()).baseIndex(), C2NumberStruct::baseIndex); 1109 EXPECT_EQ(C2Param::Type(outp2.type()).paramIndex(), kParamIndexNumber); 1110 EXPECT_EQ(outp2.type(), C2NumberPortTuning::output::typeIndex); 1111 EXPECT_EQ(outp2.stream(), ~0u); 1112 1113 C2Param::BaseIndex index = C2NumberPortTuning::input::typeIndex; 1114 EXPECT_FALSE(index.isVendor()); 1115 EXPECT_FALSE(index.isFlexible()); 1116 EXPECT_EQ(index.baseIndex(), kParamIndexNumber); 1117 EXPECT_EQ(index.paramIndex(), kParamIndexNumber); 1118 1119 index = C2NumberPortTuning::output::typeIndex; 1120 EXPECT_FALSE(index.isVendor()); 1121 EXPECT_FALSE(index.isFlexible()); 1122 EXPECT_EQ(index.baseIndex(), kParamIndexNumber); 1123 EXPECT_EQ(index.paramIndex(), kParamIndexNumber); 1124 1125 C2Param::Type type = C2NumberPortTuning::input::typeIndex; 1126 EXPECT_FALSE(type.isVendor()); 1127 EXPECT_FALSE(type.isFlexible()); 1128 EXPECT_FALSE(type.isGlobal()); 1129 EXPECT_TRUE(type.forInput()); 1130 EXPECT_FALSE(type.forOutput()); 1131 EXPECT_FALSE(type.forStream()); 1132 EXPECT_TRUE(type.forPort()); 1133 1134 type = C2NumberPortTuning::output::typeIndex; 1135 EXPECT_FALSE(type.isVendor()); 1136 EXPECT_FALSE(type.isFlexible()); 1137 EXPECT_FALSE(type.isGlobal()); 1138 EXPECT_FALSE(type.forInput()); 1139 EXPECT_TRUE(type.forOutput()); 1140 EXPECT_FALSE(type.forStream()); 1141 EXPECT_TRUE(type.forPort()); 1142 1143 EXPECT_EQ(C2NumberPortTuning::From(nullptr), nullptr); 1144 EXPECT_EQ(C2NumberPortTuning::input::From(nullptr), nullptr); 1145 EXPECT_EQ(C2NumberPortTuning::output::From(nullptr), nullptr); 1146 EXPECT_EQ(C2NumberTuning::From(&inp1), nullptr); 1147 EXPECT_EQ(C2NumberTuning::From(&inp2), nullptr); 1148 EXPECT_EQ(C2NumberTuning::From(&outp1), nullptr); 1149 EXPECT_EQ(C2NumberTuning::From(&outp2), nullptr); 1150 EXPECT_EQ(C2NumberPortTuning::From(&inp1), &inp1); 1151 EXPECT_EQ(C2NumberPortTuning::From(&inp2), (C2NumberPortTuning*)&inp2); 1152 EXPECT_EQ(C2NumberPortTuning::From(&outp1), &outp1); 1153 EXPECT_EQ(C2NumberPortTuning::From(&outp2), (C2NumberPortTuning*)&outp2); 1154 EXPECT_EQ(C2NumberPortTuning::input::From(&inp1), (C2NumberPortTuning::input*)&inp1); 1155 EXPECT_EQ(C2NumberPortTuning::input::From(&inp2), &inp2); 1156 EXPECT_EQ(C2NumberPortTuning::input::From(&outp1), nullptr); 1157 EXPECT_EQ(C2NumberPortTuning::input::From(&outp2), nullptr); 1158 EXPECT_EQ(C2NumberPortTuning::output::From(&inp1), nullptr); 1159 EXPECT_EQ(C2NumberPortTuning::output::From(&inp2), nullptr); 1160 EXPECT_EQ(C2NumberPortTuning::output::From(&outp1), (C2NumberPortTuning::output*)&outp1); 1161 EXPECT_EQ(C2NumberPortTuning::output::From(&outp2), &outp2); 1162 EXPECT_EQ(C2NumberStreamTuning::From(&inp1), nullptr); 1163 EXPECT_EQ(C2NumberStreamTuning::From(&inp2), nullptr); 1164 EXPECT_EQ(C2NumberStreamTuning::From(&outp1), nullptr); 1165 EXPECT_EQ(C2NumberStreamTuning::From(&outp2), nullptr); 1166 EXPECT_EQ(C2NumberStreamTuning::input::From(&inp1), nullptr); 1167 EXPECT_EQ(C2NumberStreamTuning::input::From(&inp2), nullptr); 1168 EXPECT_EQ(C2NumberStreamTuning::input::From(&outp1), nullptr); 1169 EXPECT_EQ(C2NumberStreamTuning::input::From(&outp2), nullptr); 1170 EXPECT_EQ(C2NumberStreamTuning::output::From(&inp1), nullptr); 1171 EXPECT_EQ(C2NumberStreamTuning::output::From(&inp2), nullptr); 1172 EXPECT_EQ(C2NumberStreamTuning::output::From(&outp1), nullptr); 1173 EXPECT_EQ(C2NumberStreamTuning::output::From(&outp2), nullptr); 1174 } 1175 1176 const C2NumberStreamTuning outs1(true, 1u, 100), ins1(false, 1u, 100); 1177 C2NumberStreamTuning bouts1, bins1, bins3(false, 1u, 100); 1178 const C2NumberStreamTuning::input ins2(1u, 100); 1179 C2NumberStreamTuning::input bins2; 1180 const C2NumberStreamTuning::output outs2(1u, 100); 1181 C2NumberStreamTuning::output bouts2; 1182 1183 { 1184 static_assert(canCallSetPort(bins3), "should be able to"); 1185 static_assert(canCallSetPort(bins1), "should be able to"); 1186 static_assert(!canCallSetPort(ins1), "should not be able to (const)"); 1187 static_assert(!canCallSetPort(ins2), "should not be able to (const & type)"); 1188 static_assert(!canCallSetPort(bins2), "should not be able to (type)"); 1189 1190 // flags & invariables 1191 for (const auto &p : { outs1, ins1, bouts1 }) { 1192 EXPECT_EQ(12u, p.size()); 1193 EXPECT_FALSE(p.isVendor()); 1194 EXPECT_FALSE(p.isFlexible()); 1195 EXPECT_FALSE(p.isGlobal()); 1196 EXPECT_TRUE(p.forStream()); 1197 EXPECT_FALSE(p.forPort()); 1198 } 1199 for (const auto &p : { ins2, bins2 }) { 1200 EXPECT_EQ(12u, p.size()); 1201 EXPECT_FALSE(p.isVendor()); 1202 EXPECT_FALSE(p.isFlexible()); 1203 EXPECT_FALSE(p.isGlobal()); 1204 EXPECT_TRUE(p.forStream()); 1205 EXPECT_FALSE(p.forPort()); 1206 } 1207 for (const auto &p : { outs2, bouts2 }) { 1208 EXPECT_EQ(12u, p.size()); 1209 EXPECT_FALSE(p.isVendor()); 1210 EXPECT_FALSE(p.isFlexible()); 1211 EXPECT_FALSE(p.isGlobal()); 1212 EXPECT_TRUE(p.forStream()); 1213 EXPECT_FALSE(p.forPort()); 1214 } 1215 1216 // port specific flags & invariables 1217 EXPECT_FALSE(outs1.forInput()); 1218 EXPECT_TRUE(outs1.forOutput()); 1219 1220 EXPECT_TRUE(ins1.forInput()); 1221 EXPECT_FALSE(ins1.forOutput()); 1222 1223 for (const auto &p : { outs1, ins1 }) { 1224 EXPECT_TRUE((bool)p); 1225 EXPECT_FALSE(!p); 1226 EXPECT_EQ(100, p.mNumber); 1227 EXPECT_EQ(1u, p.stream()); 1228 } 1229 for (const auto &p : { outs2, bouts2 }) { 1230 EXPECT_TRUE((bool)p); 1231 EXPECT_FALSE(!p); 1232 1233 EXPECT_FALSE(p.forInput()); 1234 EXPECT_TRUE(p.forOutput()); 1235 } 1236 for (const auto &p : { ins2, bins2 }) { 1237 EXPECT_TRUE((bool)p); 1238 EXPECT_FALSE(!p); 1239 1240 EXPECT_TRUE(p.forInput()); 1241 EXPECT_FALSE(p.forOutput()); 1242 } 1243 for (const auto &p : { bouts1 } ) { 1244 EXPECT_FALSE((bool)p); 1245 EXPECT_TRUE(!p); 1246 1247 EXPECT_FALSE(p.forInput()); 1248 EXPECT_FALSE(p.forOutput()); 1249 EXPECT_EQ(0, p.mNumber); 1250 } 1251 1252 // values 1253 EXPECT_EQ(100, ins2.mNumber); 1254 EXPECT_EQ(100, outs2.mNumber); 1255 EXPECT_EQ(0, bins1.mNumber); 1256 EXPECT_EQ(0, bins2.mNumber); 1257 EXPECT_EQ(0, bouts1.mNumber); 1258 EXPECT_EQ(0, bouts2.mNumber); 1259 1260 EXPECT_EQ(1u, ins2.stream()); 1261 EXPECT_EQ(1u, outs2.stream()); 1262 EXPECT_EQ(0u, bins1.stream()); 1263 EXPECT_EQ(0u, bins2.stream()); 1264 EXPECT_EQ(0u, bouts1.stream()); 1265 EXPECT_EQ(0u, bouts2.stream()); 1266 1267 EXPECT_TRUE(ins1 != outs1); 1268 EXPECT_TRUE(ins1 == ins2); 1269 EXPECT_TRUE(outs1 == outs2); 1270 EXPECT_TRUE(bins1 == bouts1); 1271 EXPECT_TRUE(bins2 != bouts2); 1272 1273 EXPECT_TRUE(ins1 != bins1); 1274 bins1.mNumber = 100; 1275 EXPECT_TRUE(ins1 != bins1); 1276 bins1.setPort(false /* output */); 1277 EXPECT_TRUE(ins1 != bins1); 1278 bins1.setStream(1u); 1279 EXPECT_TRUE(ins1 == bins1); 1280 1281 EXPECT_TRUE(ins2 != bins2); 1282 bins2.mNumber = 100; 1283 EXPECT_TRUE(ins2 != bins2); 1284 bins2.setStream(1u); 1285 EXPECT_TRUE(ins2 == bins2); 1286 1287 bins1.setPort(true /* output */); 1288 EXPECT_TRUE(outs1 == bins1); 1289 1290 EXPECT_TRUE(outs1 != bouts1); 1291 bouts1.mNumber = 100; 1292 EXPECT_TRUE(outs1 != bouts1); 1293 bouts1.setPort(true /* output */); 1294 EXPECT_TRUE(outs1 != bouts1); 1295 bouts1.setStream(1u); 1296 EXPECT_TRUE(outs1 == bouts1); 1297 1298 EXPECT_TRUE(outs2 != bouts2); 1299 bouts2.mNumber = 100; 1300 EXPECT_TRUE(outs2 != bouts2); 1301 bouts2.setStream(1u); 1302 EXPECT_TRUE(outs2 == bouts2); 1303 1304 bouts1.setPort(false /* output */); 1305 EXPECT_TRUE(ins1 == bouts1); 1306 1307 // index 1308 EXPECT_EQ(C2Param::Type(ins1.type()).baseIndex(), C2NumberStruct::baseIndex); 1309 EXPECT_EQ(C2Param::Type(ins1.type()).paramIndex(), kParamIndexNumber); 1310 EXPECT_EQ(ins1.type(), C2NumberStreamTuning::input::typeIndex); 1311 1312 EXPECT_EQ(C2Param::Type(ins2.type()).baseIndex(), C2NumberStruct::baseIndex); 1313 EXPECT_EQ(C2Param::Type(ins2.type()).paramIndex(), kParamIndexNumber); 1314 EXPECT_EQ(ins2.type(), C2NumberStreamTuning::input::typeIndex); 1315 1316 EXPECT_EQ(C2Param::Type(outs1.type()).baseIndex(), C2NumberStruct::baseIndex); 1317 EXPECT_EQ(C2Param::Type(outs1.type()).paramIndex(), kParamIndexNumber); 1318 EXPECT_EQ(outs1.type(), C2NumberStreamTuning::output::typeIndex); 1319 1320 EXPECT_EQ(C2Param::Type(outs2.type()).baseIndex(), C2NumberStruct::baseIndex); 1321 EXPECT_EQ(C2Param::Type(outs2.type()).paramIndex(), kParamIndexNumber); 1322 EXPECT_EQ(outs2.type(), C2NumberStreamTuning::output::typeIndex); 1323 1324 C2Param::BaseIndex index = C2NumberStreamTuning::input::typeIndex; 1325 EXPECT_FALSE(index.isVendor()); 1326 EXPECT_FALSE(index.isFlexible()); 1327 EXPECT_EQ(index.baseIndex(), kParamIndexNumber); 1328 EXPECT_EQ(index.paramIndex(), kParamIndexNumber); 1329 1330 index = C2NumberStreamTuning::output::typeIndex; 1331 EXPECT_FALSE(index.isVendor()); 1332 EXPECT_FALSE(index.isFlexible()); 1333 EXPECT_EQ(index.baseIndex(), kParamIndexNumber); 1334 EXPECT_EQ(index.paramIndex(), kParamIndexNumber); 1335 1336 C2Param::Type type = C2NumberStreamTuning::input::typeIndex; 1337 EXPECT_FALSE(type.isVendor()); 1338 EXPECT_FALSE(type.isFlexible()); 1339 EXPECT_FALSE(type.isGlobal()); 1340 EXPECT_TRUE(type.forInput()); 1341 EXPECT_FALSE(type.forOutput()); 1342 EXPECT_TRUE(type.forStream()); 1343 EXPECT_FALSE(type.forPort()); 1344 1345 type = C2NumberStreamTuning::output::typeIndex; 1346 EXPECT_FALSE(type.isVendor()); 1347 EXPECT_FALSE(type.isFlexible()); 1348 EXPECT_FALSE(type.isGlobal()); 1349 EXPECT_FALSE(type.forInput()); 1350 EXPECT_TRUE(type.forOutput()); 1351 EXPECT_TRUE(type.forStream()); 1352 EXPECT_FALSE(type.forPort()); 1353 1354 EXPECT_EQ(C2NumberPortTuning::From(nullptr), nullptr); 1355 EXPECT_EQ(C2NumberPortTuning::input::From(nullptr), nullptr); 1356 EXPECT_EQ(C2NumberPortTuning::output::From(nullptr), nullptr); 1357 EXPECT_EQ(C2NumberTuning::From(&ins1), nullptr); 1358 EXPECT_EQ(C2NumberTuning::From(&ins2), nullptr); 1359 EXPECT_EQ(C2NumberTuning::From(&outs1), nullptr); 1360 EXPECT_EQ(C2NumberTuning::From(&outs2), nullptr); 1361 EXPECT_EQ(C2NumberPortTuning::From(&ins1), nullptr); 1362 EXPECT_EQ(C2NumberPortTuning::From(&ins2), nullptr); 1363 EXPECT_EQ(C2NumberPortTuning::From(&outs1), nullptr); 1364 EXPECT_EQ(C2NumberPortTuning::From(&outs2), nullptr); 1365 EXPECT_EQ(C2NumberPortTuning::input::From(&ins1), nullptr); 1366 EXPECT_EQ(C2NumberPortTuning::input::From(&ins2), nullptr); 1367 EXPECT_EQ(C2NumberPortTuning::input::From(&outs1), nullptr); 1368 EXPECT_EQ(C2NumberPortTuning::input::From(&outs2), nullptr); 1369 EXPECT_EQ(C2NumberPortTuning::output::From(&ins1), nullptr); 1370 EXPECT_EQ(C2NumberPortTuning::output::From(&ins2), nullptr); 1371 EXPECT_EQ(C2NumberPortTuning::output::From(&outs1), nullptr); 1372 EXPECT_EQ(C2NumberPortTuning::output::From(&outs2), nullptr); 1373 EXPECT_EQ(C2NumberStreamTuning::From(&ins1), &ins1); 1374 EXPECT_EQ(C2NumberStreamTuning::From(&ins2), (C2NumberStreamTuning*)&ins2); 1375 EXPECT_EQ(C2NumberStreamTuning::From(&outs1), &outs1); 1376 EXPECT_EQ(C2NumberStreamTuning::From(&outs2), (C2NumberStreamTuning*)&outs2); 1377 EXPECT_EQ(C2NumberStreamTuning::input::From(&ins1), (C2NumberStreamTuning::input*)&ins1); 1378 EXPECT_EQ(C2NumberStreamTuning::input::From(&ins2), &ins2); 1379 EXPECT_EQ(C2NumberStreamTuning::input::From(&outs1), nullptr); 1380 EXPECT_EQ(C2NumberStreamTuning::input::From(&outs2), nullptr); 1381 EXPECT_EQ(C2NumberStreamTuning::output::From(&ins1), nullptr); 1382 EXPECT_EQ(C2NumberStreamTuning::output::From(&ins2), nullptr); 1383 EXPECT_EQ(C2NumberStreamTuning::output::From(&outs1), (C2NumberStreamTuning::output*)&outs1); 1384 EXPECT_EQ(C2NumberStreamTuning::output::From(&outs2), &outs2); 1385 1386 } 1387 1388 { 1389 uint32_t videoWidth[] = { 12u, C2NumberStreamTuning::output::typeIndex, 100 }; 1390 C2Param *p1 = C2Param::From(videoWidth, sizeof(videoWidth)); 1391 EXPECT_NE(p1, nullptr); 1392 EXPECT_EQ(12u, p1->size()); 1393 EXPECT_EQ(p1->type(), C2NumberStreamTuning::output::typeIndex); 1394 1395 p1 = C2Param::From(videoWidth, sizeof(videoWidth) + 2); 1396 EXPECT_EQ(p1, nullptr); 1397 1398 p1 = C2Param::From(videoWidth, sizeof(videoWidth) - 2); 1399 EXPECT_EQ(p1, nullptr); 1400 1401 p1 = C2Param::From(videoWidth, 3); 1402 EXPECT_EQ(p1, nullptr); 1403 1404 p1 = C2Param::From(videoWidth, 0); 1405 EXPECT_EQ(p1, nullptr); 1406 } 1407} 1408 1409void StaticTestAddBaseIndex() { 1410 struct nobase {}; 1411 struct base { enum : uint32_t { baseIndex = 1 }; }; 1412 static_assert(C2AddBaseIndex<nobase, 2>::baseIndex == 2, "should be 2"); 1413 static_assert(C2AddBaseIndex<base, 1>::baseIndex == 1, "should be 1"); 1414} 1415 1416class TestFlexHelper { 1417 struct _Flex { 1418 int32_t a; 1419 char b[]; 1420 _Flex() {} 1421 FLEX(_Flex, b); 1422 }; 1423 1424 struct _BoFlex { 1425 _Flex a; 1426 _BoFlex() {} 1427 FLEX(_BoFlex, a); 1428 }; 1429 1430 struct _NonFlex { 1431 }; 1432 1433 1434 static void StaticTest() { 1435 static_assert(std::is_same<_C2FlexHelper<char>::flexType, void>::value, "should be void"); 1436 static_assert(std::is_same<_C2FlexHelper<char[]>::flexType, char>::value, "should be char"); 1437 static_assert(std::is_same<_C2FlexHelper<_Flex>::flexType, char>::value, "should be char"); 1438 1439 static_assert(std::is_same<_C2FlexHelper<_BoFlex>::flexType, char>::value, "should be void"); 1440 1441 static_assert(_C2Flexible<_Flex>::value, "should be flexible"); 1442 static_assert(!_C2Flexible<_NonFlex>::value, "should not be flexible"); 1443 } 1444}; 1445 1446TEST_F(C2ParamTest, FlexParamOpsTest) { 1447// const C2NumbersStruct str{100}; 1448 C2NumbersStruct bstr; 1449 { 1450// EXPECT_EQ(100, str->m.mNumbers[0]); 1451 (void)&bstr.mNumbers[0]; 1452 1453 C2Param::BaseIndex index = C2NumbersStruct::baseIndex; 1454 EXPECT_FALSE(index.isVendor()); 1455 EXPECT_TRUE(index.isFlexible()); 1456 EXPECT_EQ(index.baseIndex(), kParamIndexNumbers | C2Param::BaseIndex::_kFlexibleFlag); 1457 EXPECT_EQ(index.paramIndex(), kParamIndexNumbers); 1458 } 1459 1460 std::unique_ptr<C2NumbersTuning> tun_ = C2NumbersTuning::alloc_unique(1); 1461 tun_->m.mNumbers[0] = 100; 1462 std::unique_ptr<const C2NumbersTuning> tun = std::move(tun_); 1463 std::shared_ptr<C2NumbersTuning> btun = C2NumbersTuning::alloc_shared(1); 1464 1465 { 1466 // flags & invariables 1467 const C2NumbersTuning *T[] = { tun.get(), btun.get() }; 1468 for (const auto p : T) { 1469 EXPECT_TRUE((bool)(*p)); 1470 EXPECT_FALSE(!(*p)); 1471 EXPECT_EQ(12u, p->size()); 1472 1473 EXPECT_FALSE(p->isVendor()); 1474 EXPECT_TRUE(p->isFlexible()); 1475 EXPECT_TRUE(p->isGlobal()); 1476 EXPECT_FALSE(p->forInput()); 1477 EXPECT_FALSE(p->forOutput()); 1478 EXPECT_FALSE(p->forStream()); 1479 EXPECT_FALSE(p->forPort()); 1480 } 1481 1482 // value 1483 EXPECT_EQ(100, tun->m.mNumbers[0]); 1484 EXPECT_EQ(0, btun->m.mNumbers[0]); 1485 EXPECT_FALSE(*tun == *btun); 1486 EXPECT_FALSE(tun->operator==(*btun)); 1487 EXPECT_TRUE(*tun != *btun); 1488 EXPECT_TRUE(tun->operator!=(*btun)); 1489 btun->m.mNumbers[0] = 100; 1490 EXPECT_EQ(*tun, *btun); 1491 1492 // index 1493 EXPECT_EQ(C2Param::Type(tun->type()).baseIndex(), C2NumbersStruct::baseIndex); 1494 EXPECT_EQ(C2Param::Type(tun->type()).paramIndex(), kParamIndexNumbers); 1495 EXPECT_EQ(tun->type(), C2NumbersTuning::typeIndex); 1496 EXPECT_EQ(tun->stream(), ~0u); 1497 1498 C2Param::BaseIndex index = C2NumbersTuning::baseIndex; 1499 EXPECT_FALSE(index.isVendor()); 1500 EXPECT_TRUE(index.isFlexible()); 1501 EXPECT_EQ(index.baseIndex(), kParamIndexNumbers | C2Param::BaseIndex::_kFlexibleFlag); 1502 EXPECT_EQ(index.paramIndex(), kParamIndexNumbers); 1503 1504 C2Param::Type type = C2NumbersTuning::typeIndex; 1505 EXPECT_FALSE(type.isVendor()); 1506 EXPECT_TRUE(type.isFlexible()); 1507 EXPECT_TRUE(type.isGlobal()); 1508 EXPECT_FALSE(type.forInput()); 1509 EXPECT_FALSE(type.forOutput()); 1510 EXPECT_FALSE(type.forStream()); 1511 EXPECT_FALSE(type.forPort()); 1512 1513 EXPECT_EQ(C2NumbersTuning::From(nullptr), nullptr); 1514 EXPECT_EQ(C2NumbersTuning::From(tun.get()), tun.get()); 1515 EXPECT_EQ(C2NumbersPortTuning::From(tun.get()), nullptr); 1516 EXPECT_EQ(C2NumbersPortTuning::input::From(tun.get()), nullptr); 1517 EXPECT_EQ(C2NumbersPortTuning::output::From(tun.get()), nullptr); 1518 EXPECT_EQ(C2NumbersStreamTuning::From(tun.get()), nullptr); 1519 EXPECT_EQ(C2NumbersStreamTuning::input::From(tun.get()), nullptr); 1520 EXPECT_EQ(C2NumbersStreamTuning::output::From(tun.get()), nullptr); 1521 } 1522 1523 std::unique_ptr<C2NumbersPortTuning> outp1_(C2NumbersPortTuning::alloc_unique(1, true)), 1524 inp1_ = C2NumbersPortTuning::alloc_unique(1, false); 1525 outp1_->m.mNumbers[0] = 100; 1526 inp1_->m.mNumbers[0] = 100; 1527 std::unique_ptr<const C2NumbersPortTuning> outp1 = std::move(outp1_); 1528 std::unique_ptr<const C2NumbersPortTuning> inp1 = std::move(inp1_); 1529 std::shared_ptr<C2NumbersPortTuning> boutp1(C2NumbersPortTuning::alloc_shared(1)), 1530 binp1 = C2NumbersPortTuning::alloc_shared(1), 1531 binp3 = C2NumbersPortTuning::alloc_shared(1, false); 1532 binp3->m.mNumbers[0] = 100; 1533 std::unique_ptr<C2NumbersPortTuning::input> inp2_(C2NumbersPortTuning::input::alloc_unique(1)); 1534 inp2_->m.mNumbers[0] = 100; 1535 std::unique_ptr<const C2NumbersPortTuning::input> inp2 = std::move(inp2_); 1536 std::shared_ptr<C2NumbersPortTuning::input> binp2(C2NumbersPortTuning::input::alloc_shared(1)); 1537 std::unique_ptr<C2NumbersPortTuning::output> outp2_(C2NumbersPortTuning::output::alloc_unique(1)); 1538 outp2_->m.mNumbers[0] = 100; 1539 std::unique_ptr<const C2NumbersPortTuning::output> outp2 = std::move(outp2_); 1540 std::shared_ptr<C2NumbersPortTuning::output> boutp2(C2NumbersPortTuning::output::alloc_shared(1)); 1541 1542 { 1543 static_assert(canCallSetPort(*binp3), "should be able to"); 1544 static_assert(canCallSetPort(*binp1), "should be able to"); 1545 static_assert(!canCallSetPort(*inp1), "should not be able to (const)"); 1546 static_assert(!canCallSetPort(*inp2), "should not be able to (const & type)"); 1547 static_assert(!canCallSetPort(*binp2), "should not be able to (type)"); 1548 1549 // flags & invariables 1550 const C2NumbersPortTuning *P[] = { outp1.get(), inp1.get(), boutp1.get() }; 1551 for (const auto p : P) { 1552 EXPECT_EQ(12u, p->size()); 1553 EXPECT_FALSE(p->isVendor()); 1554 EXPECT_TRUE(p->isFlexible()); 1555 EXPECT_FALSE(p->isGlobal()); 1556 EXPECT_FALSE(p->forStream()); 1557 EXPECT_TRUE(p->forPort()); 1558 } 1559 const C2NumbersPortTuning::input *PI[] = { inp2.get(), binp2.get() }; 1560 for (const auto p : PI) { 1561 EXPECT_EQ(12u, p->size()); 1562 EXPECT_FALSE(p->isVendor()); 1563 EXPECT_TRUE(p->isFlexible()); 1564 EXPECT_FALSE(p->isGlobal()); 1565 EXPECT_FALSE(p->forStream()); 1566 EXPECT_TRUE(p->forPort()); 1567 } 1568 const C2NumbersPortTuning::output *PO[] = { outp2.get(), boutp2.get() }; 1569 for (const auto p : PO) { 1570 EXPECT_EQ(12u, p->size()); 1571 EXPECT_FALSE(p->isVendor()); 1572 EXPECT_TRUE(p->isFlexible()); 1573 EXPECT_FALSE(p->isGlobal()); 1574 EXPECT_FALSE(p->forStream()); 1575 EXPECT_TRUE(p->forPort()); 1576 } 1577 1578 // port specific flags & invariables 1579 EXPECT_FALSE(outp1->forInput()); 1580 EXPECT_TRUE(outp1->forOutput()); 1581 1582 EXPECT_TRUE(inp1->forInput()); 1583 EXPECT_FALSE(inp1->forOutput()); 1584 1585 const C2NumbersPortTuning *P2[] = { outp1.get(), inp1.get() }; 1586 for (const auto p : P2) { 1587 EXPECT_TRUE((bool)(*p)); 1588 EXPECT_FALSE(!(*p)); 1589 EXPECT_EQ(100, p->m.mNumbers[0]); 1590 } 1591 for (const auto p : PO) { 1592 EXPECT_TRUE((bool)(*p)); 1593 EXPECT_FALSE(!(*p)); 1594 1595 EXPECT_FALSE(p->forInput()); 1596 EXPECT_TRUE(p->forOutput()); 1597 } 1598 for (const auto p : PI) { 1599 EXPECT_TRUE((bool)(*p)); 1600 EXPECT_FALSE(!(*p)); 1601 1602 EXPECT_TRUE(p->forInput()); 1603 EXPECT_FALSE(p->forOutput()); 1604 } 1605 const C2NumbersPortTuning *P3[] = { boutp1.get() }; 1606 for (const auto p : P3) { 1607 EXPECT_FALSE((bool)(*p)); 1608 EXPECT_TRUE(!(*p)); 1609 1610 EXPECT_FALSE(p->forInput()); 1611 EXPECT_FALSE(p->forOutput()); 1612 EXPECT_EQ(0, p->m.mNumbers[0]); 1613 } 1614 1615 // values 1616 EXPECT_EQ(100, inp2->m.mNumbers[0]); 1617 EXPECT_EQ(100, outp2->m.mNumbers[0]); 1618 EXPECT_EQ(0, binp1->m.mNumbers[0]); 1619 EXPECT_EQ(0, binp2->m.mNumbers[0]); 1620 EXPECT_EQ(0, boutp1->m.mNumbers[0]); 1621 EXPECT_EQ(0, boutp2->m.mNumbers[0]); 1622 1623 EXPECT_TRUE(*inp1 != *outp1); 1624 EXPECT_TRUE(*inp1 == *inp2); 1625 EXPECT_TRUE(*outp1 == *outp2); 1626 EXPECT_TRUE(*binp1 == *boutp1); 1627 EXPECT_TRUE(*binp2 != *boutp2); 1628 1629 EXPECT_TRUE(*inp1 != *binp1); 1630 binp1->m.mNumbers[0] = 100; 1631 EXPECT_TRUE(*inp1 != *binp1); 1632 binp1->setPort(false /* output */); 1633 EXPECT_TRUE((bool)*binp1); 1634 EXPECT_FALSE(!*binp1); 1635 EXPECT_TRUE(*inp1 == *binp1); 1636 1637 EXPECT_TRUE(*inp2 != *binp2); 1638 binp2->m.mNumbers[0] = 100; 1639 EXPECT_TRUE(*inp2 == *binp2); 1640 1641 binp1->setPort(true /* output */); 1642 EXPECT_TRUE(*outp1 == *binp1); 1643 1644 EXPECT_TRUE(*outp1 != *boutp1); 1645 boutp1->m.mNumbers[0] = 100; 1646 EXPECT_TRUE(*outp1 != *boutp1); 1647 boutp1->setPort(true /* output */); 1648 EXPECT_TRUE((bool)*boutp1); 1649 EXPECT_FALSE(!*boutp1); 1650 EXPECT_TRUE(*outp1 == *boutp1); 1651 1652 EXPECT_TRUE(*outp2 != *boutp2); 1653 boutp2->m.mNumbers[0] = 100; 1654 EXPECT_TRUE(*outp2 == *boutp2); 1655 1656 boutp1->setPort(false /* output */); 1657 EXPECT_TRUE(*inp1 == *boutp1); 1658 1659 // index 1660 EXPECT_EQ(C2Param::Type(inp1->type()).baseIndex(), C2NumbersStruct::baseIndex); 1661 EXPECT_EQ(C2Param::Type(inp1->type()).paramIndex(), kParamIndexNumbers); 1662 EXPECT_EQ(inp1->type(), C2NumbersPortTuning::input::typeIndex); 1663 EXPECT_EQ(inp1->stream(), ~0u); 1664 1665 EXPECT_EQ(C2Param::Type(inp2->type()).baseIndex(), C2NumbersStruct::baseIndex); 1666 EXPECT_EQ(C2Param::Type(inp2->type()).paramIndex(), kParamIndexNumbers); 1667 EXPECT_EQ(inp2->type(), C2NumbersPortTuning::input::typeIndex); 1668 EXPECT_EQ(inp2->stream(), ~0u); 1669 1670 EXPECT_EQ(C2Param::Type(outp1->type()).baseIndex(), C2NumbersStruct::baseIndex); 1671 EXPECT_EQ(C2Param::Type(outp1->type()).paramIndex(), kParamIndexNumbers); 1672 EXPECT_EQ(outp1->type(), C2NumbersPortTuning::output::typeIndex); 1673 EXPECT_EQ(outp1->stream(), ~0u); 1674 1675 EXPECT_EQ(C2Param::Type(outp2->type()).baseIndex(), C2NumbersStruct::baseIndex); 1676 EXPECT_EQ(C2Param::Type(outp2->type()).paramIndex(), kParamIndexNumbers); 1677 EXPECT_EQ(outp2->type(), C2NumbersPortTuning::output::typeIndex); 1678 EXPECT_EQ(outp2->stream(), ~0u); 1679 1680 C2Param::BaseIndex index = C2NumbersPortTuning::input::typeIndex; 1681 EXPECT_FALSE(index.isVendor()); 1682 EXPECT_TRUE(index.isFlexible()); 1683 EXPECT_EQ(index.baseIndex(), kParamIndexNumbers | C2Param::BaseIndex::_kFlexibleFlag); 1684 EXPECT_EQ(index.paramIndex(), kParamIndexNumbers); 1685 1686 index = C2NumbersPortTuning::output::typeIndex; 1687 EXPECT_FALSE(index.isVendor()); 1688 EXPECT_TRUE(index.isFlexible()); 1689 EXPECT_EQ(index.baseIndex(), kParamIndexNumbers | C2Param::BaseIndex::_kFlexibleFlag); 1690 EXPECT_EQ(index.paramIndex(), kParamIndexNumbers); 1691 1692 C2Param::Type type = C2NumbersPortTuning::input::typeIndex; 1693 EXPECT_FALSE(type.isVendor()); 1694 EXPECT_TRUE(type.isFlexible()); 1695 EXPECT_FALSE(type.isGlobal()); 1696 EXPECT_TRUE(type.forInput()); 1697 EXPECT_FALSE(type.forOutput()); 1698 EXPECT_FALSE(type.forStream()); 1699 EXPECT_TRUE(type.forPort()); 1700 1701 type = C2NumbersPortTuning::output::typeIndex; 1702 EXPECT_FALSE(type.isVendor()); 1703 EXPECT_TRUE(type.isFlexible()); 1704 EXPECT_FALSE(type.isGlobal()); 1705 EXPECT_FALSE(type.forInput()); 1706 EXPECT_TRUE(type.forOutput()); 1707 EXPECT_FALSE(type.forStream()); 1708 EXPECT_TRUE(type.forPort()); 1709 1710 EXPECT_EQ(C2NumbersPortTuning::From(nullptr), nullptr); 1711 EXPECT_EQ(C2NumbersPortTuning::input::From(nullptr), nullptr); 1712 EXPECT_EQ(C2NumbersPortTuning::output::From(nullptr), nullptr); 1713 EXPECT_EQ(C2NumbersTuning::From(inp1.get()), nullptr); 1714 EXPECT_EQ(C2NumbersTuning::From(inp2.get()), nullptr); 1715 EXPECT_EQ(C2NumbersTuning::From(outp1.get()), nullptr); 1716 EXPECT_EQ(C2NumbersTuning::From(outp2.get()), nullptr); 1717 EXPECT_EQ(C2NumbersPortTuning::From(inp1.get()), inp1.get()); 1718 EXPECT_EQ(C2NumbersPortTuning::From(inp2.get()), (C2NumbersPortTuning*)inp2.get()); 1719 EXPECT_EQ(C2NumbersPortTuning::From(outp1.get()), outp1.get()); 1720 EXPECT_EQ(C2NumbersPortTuning::From(outp2.get()), (C2NumbersPortTuning*)outp2.get()); 1721 EXPECT_EQ(C2NumbersPortTuning::input::From(inp1.get()), (C2NumbersPortTuning::input*)inp1.get()); 1722 EXPECT_EQ(C2NumbersPortTuning::input::From(inp2.get()), inp2.get()); 1723 EXPECT_EQ(C2NumbersPortTuning::input::From(outp1.get()), nullptr); 1724 EXPECT_EQ(C2NumbersPortTuning::input::From(outp2.get()), nullptr); 1725 EXPECT_EQ(C2NumbersPortTuning::output::From(inp1.get()), nullptr); 1726 EXPECT_EQ(C2NumbersPortTuning::output::From(inp2.get()), nullptr); 1727 EXPECT_EQ(C2NumbersPortTuning::output::From(outp1.get()), (C2NumbersPortTuning::output*)outp1.get()); 1728 EXPECT_EQ(C2NumbersPortTuning::output::From(outp2.get()), outp2.get()); 1729 EXPECT_EQ(C2NumbersStreamTuning::From(inp1.get()), nullptr); 1730 EXPECT_EQ(C2NumbersStreamTuning::From(inp2.get()), nullptr); 1731 EXPECT_EQ(C2NumbersStreamTuning::From(outp1.get()), nullptr); 1732 EXPECT_EQ(C2NumbersStreamTuning::From(outp2.get()), nullptr); 1733 EXPECT_EQ(C2NumbersStreamTuning::input::From(inp1.get()), nullptr); 1734 EXPECT_EQ(C2NumbersStreamTuning::input::From(inp2.get()), nullptr); 1735 EXPECT_EQ(C2NumbersStreamTuning::input::From(outp1.get()), nullptr); 1736 EXPECT_EQ(C2NumbersStreamTuning::input::From(outp2.get()), nullptr); 1737 EXPECT_EQ(C2NumbersStreamTuning::output::From(inp1.get()), nullptr); 1738 EXPECT_EQ(C2NumbersStreamTuning::output::From(inp2.get()), nullptr); 1739 EXPECT_EQ(C2NumbersStreamTuning::output::From(outp1.get()), nullptr); 1740 EXPECT_EQ(C2NumbersStreamTuning::output::From(outp2.get()), nullptr); 1741 1742 } 1743 1744 std::unique_ptr<C2NumbersStreamTuning> outs1_(C2NumbersStreamTuning::alloc_unique(1, true, 1u)); 1745 outs1_->m.mNumbers[0] = 100; 1746 std::unique_ptr<const C2NumbersStreamTuning> outs1 = std::move(outs1_); 1747 std::unique_ptr<C2NumbersStreamTuning> ins1_(C2NumbersStreamTuning::alloc_unique(1, false, 1u)); 1748 ins1_->m.mNumbers[0] = 100; 1749 std::unique_ptr<const C2NumbersStreamTuning> ins1 = std::move(ins1_); 1750 std::shared_ptr<C2NumbersStreamTuning> bouts1(C2NumbersStreamTuning::alloc_shared(1)); 1751 std::shared_ptr<C2NumbersStreamTuning> bins1(C2NumbersStreamTuning::alloc_shared(1)); 1752 std::shared_ptr<C2NumbersStreamTuning> bins3(C2NumbersStreamTuning::alloc_shared(1, false, 1u)); 1753 bins3->m.mNumbers[0] = 100; 1754 std::unique_ptr<C2NumbersStreamTuning::input> ins2_(C2NumbersStreamTuning::input::alloc_unique(1, 1u)); 1755 ins2_->m.mNumbers[0] = 100; 1756 std::unique_ptr<const C2NumbersStreamTuning::input> ins2 = std::move(ins2_); 1757 std::shared_ptr<C2NumbersStreamTuning::input> bins2(C2NumbersStreamTuning::input::alloc_shared(1)); 1758 std::unique_ptr<C2NumbersStreamTuning::output> outs2_(C2NumbersStreamTuning::output::alloc_unique(1, 1u)); 1759 outs2_->m.mNumbers[0] = 100; 1760 std::unique_ptr<const C2NumbersStreamTuning::output> outs2 = std::move(outs2_); 1761 std::shared_ptr<C2NumbersStreamTuning::output> bouts2(C2NumbersStreamTuning::output::alloc_shared(1)); 1762 1763 { 1764 static_assert(canCallSetPort(*bins3), "should be able to"); 1765 static_assert(canCallSetPort(*bins1), "should be able to"); 1766 static_assert(!canCallSetPort(*ins1), "should not be able to (const)"); 1767 static_assert(!canCallSetPort(*ins2), "should not be able to (const & type)"); 1768 static_assert(!canCallSetPort(*bins2), "should not be able to (type)"); 1769 1770 // flags & invariables 1771 const C2NumbersStreamTuning *S[] = { outs1.get(), ins1.get(), bouts1.get() }; 1772 for (const auto p : S) { 1773 EXPECT_EQ(12u, p->size()); 1774 EXPECT_FALSE(p->isVendor()); 1775 EXPECT_TRUE(p->isFlexible()); 1776 EXPECT_FALSE(p->isGlobal()); 1777 EXPECT_TRUE(p->forStream()); 1778 EXPECT_FALSE(p->forPort()); 1779 } 1780 const C2NumbersStreamTuning::input *SI[] = { ins2.get(), bins2.get() }; 1781 for (const auto p : SI) { 1782 EXPECT_EQ(12u, p->size()); 1783 EXPECT_FALSE(p->isVendor()); 1784 EXPECT_TRUE(p->isFlexible()); 1785 EXPECT_FALSE(p->isGlobal()); 1786 EXPECT_TRUE(p->forStream()); 1787 EXPECT_FALSE(p->forPort()); 1788 } 1789 const C2NumbersStreamTuning::output *SO[] = { outs2.get(), bouts2.get() }; 1790 for (const auto p : SO) { 1791 EXPECT_EQ(12u, p->size()); 1792 EXPECT_FALSE(p->isVendor()); 1793 EXPECT_TRUE(p->isFlexible()); 1794 EXPECT_FALSE(p->isGlobal()); 1795 EXPECT_TRUE(p->forStream()); 1796 EXPECT_FALSE(p->forPort()); 1797 } 1798 1799 // port specific flags & invariables 1800 EXPECT_FALSE(outs1->forInput()); 1801 EXPECT_TRUE(outs1->forOutput()); 1802 1803 EXPECT_TRUE(ins1->forInput()); 1804 EXPECT_FALSE(ins1->forOutput()); 1805 1806 const C2NumbersStreamTuning *S2[] = { outs1.get(), ins1.get() }; 1807 for (const auto p : S2) { 1808 EXPECT_TRUE((bool)(*p)); 1809 EXPECT_FALSE(!(*p)); 1810 EXPECT_EQ(100, p->m.mNumbers[0]); 1811 EXPECT_EQ(1u, p->stream()); 1812 } 1813 for (const auto p : SO) { 1814 EXPECT_TRUE((bool)(*p)); 1815 EXPECT_FALSE(!(*p)); 1816 1817 EXPECT_FALSE(p->forInput()); 1818 EXPECT_TRUE(p->forOutput()); 1819 } 1820 for (const auto p : SI) { 1821 EXPECT_TRUE((bool)(*p)); 1822 EXPECT_FALSE(!(*p)); 1823 1824 EXPECT_TRUE(p->forInput()); 1825 EXPECT_FALSE(p->forOutput()); 1826 } 1827 const C2NumbersStreamTuning *S3[] = { bouts1.get() }; 1828 for (const auto p : S3) { 1829 EXPECT_FALSE((bool)(*p)); 1830 EXPECT_TRUE(!(*p)); 1831 1832 EXPECT_FALSE(p->forInput()); 1833 EXPECT_FALSE(p->forOutput()); 1834 EXPECT_EQ(0, p->m.mNumbers[0]); 1835 } 1836 1837 // values 1838 EXPECT_EQ(100, ins2->m.mNumbers[0]); 1839 EXPECT_EQ(100, outs2->m.mNumbers[0]); 1840 EXPECT_EQ(0, bins1->m.mNumbers[0]); 1841 EXPECT_EQ(0, bins2->m.mNumbers[0]); 1842 EXPECT_EQ(0, bouts1->m.mNumbers[0]); 1843 EXPECT_EQ(0, bouts2->m.mNumbers[0]); 1844 1845 EXPECT_EQ(1u, ins2->stream()); 1846 EXPECT_EQ(1u, outs2->stream()); 1847 EXPECT_EQ(0u, bins1->stream()); 1848 EXPECT_EQ(0u, bins2->stream()); 1849 EXPECT_EQ(0u, bouts1->stream()); 1850 EXPECT_EQ(0u, bouts2->stream()); 1851 1852 EXPECT_TRUE(*ins1 != *outs1); 1853 EXPECT_TRUE(*ins1 == *ins2); 1854 EXPECT_TRUE(*outs1 == *outs2); 1855 EXPECT_TRUE(*bins1 == *bouts1); 1856 EXPECT_TRUE(*bins2 != *bouts2); 1857 1858 EXPECT_TRUE(*ins1 != *bins1); 1859 bins1->m.mNumbers[0] = 100; 1860 EXPECT_TRUE(*ins1 != *bins1); 1861 bins1->setPort(false /* output */); 1862 EXPECT_TRUE(*ins1 != *bins1); 1863 bins1->setStream(1u); 1864 EXPECT_TRUE(*ins1 == *bins1); 1865 1866 EXPECT_TRUE(*ins2 != *bins2); 1867 bins2->m.mNumbers[0] = 100; 1868 EXPECT_TRUE(*ins2 != *bins2); 1869 bins2->setStream(1u); 1870 EXPECT_TRUE(*ins2 == *bins2); 1871 1872 bins1->setPort(true /* output */); 1873 EXPECT_TRUE(*outs1 == *bins1); 1874 1875 EXPECT_TRUE(*outs1 != *bouts1); 1876 bouts1->m.mNumbers[0] = 100; 1877 EXPECT_TRUE(*outs1 != *bouts1); 1878 bouts1->setPort(true /* output */); 1879 EXPECT_TRUE(*outs1 != *bouts1); 1880 bouts1->setStream(1u); 1881 EXPECT_TRUE(*outs1 == *bouts1); 1882 1883 EXPECT_TRUE(*outs2 != *bouts2); 1884 bouts2->m.mNumbers[0] = 100; 1885 EXPECT_TRUE(*outs2 != *bouts2); 1886 bouts2->setStream(1u); 1887 EXPECT_TRUE(*outs2 == *bouts2); 1888 1889 bouts1->setPort(false /* output */); 1890 EXPECT_TRUE(*ins1 == *bouts1); 1891 1892 // index 1893 EXPECT_EQ(C2Param::Type(ins1->type()).baseIndex(), C2NumbersStruct::baseIndex); 1894 EXPECT_EQ(C2Param::Type(ins1->type()).paramIndex(), kParamIndexNumbers); 1895 EXPECT_EQ(ins1->type(), C2NumbersStreamTuning::input::typeIndex); 1896 1897 EXPECT_EQ(C2Param::Type(ins2->type()).baseIndex(), C2NumbersStruct::baseIndex); 1898 EXPECT_EQ(C2Param::Type(ins2->type()).paramIndex(), kParamIndexNumbers); 1899 EXPECT_EQ(ins2->type(), C2NumbersStreamTuning::input::typeIndex); 1900 1901 EXPECT_EQ(C2Param::Type(outs1->type()).baseIndex(), C2NumbersStruct::baseIndex); 1902 EXPECT_EQ(C2Param::Type(outs1->type()).paramIndex(), kParamIndexNumbers); 1903 EXPECT_EQ(outs1->type(), C2NumbersStreamTuning::output::typeIndex); 1904 1905 EXPECT_EQ(C2Param::Type(outs2->type()).baseIndex(), C2NumbersStruct::baseIndex); 1906 EXPECT_EQ(C2Param::Type(outs2->type()).paramIndex(), kParamIndexNumbers); 1907 EXPECT_EQ(outs2->type(), C2NumbersStreamTuning::output::typeIndex); 1908 1909 C2Param::BaseIndex index = C2NumbersStreamTuning::input::typeIndex; 1910 EXPECT_FALSE(index.isVendor()); 1911 EXPECT_TRUE(index.isFlexible()); 1912 EXPECT_EQ(index.baseIndex(), kParamIndexNumbers | C2Param::BaseIndex::_kFlexibleFlag); 1913 EXPECT_EQ(index.paramIndex(), kParamIndexNumbers); 1914 1915 index = C2NumbersStreamTuning::output::typeIndex; 1916 EXPECT_FALSE(index.isVendor()); 1917 EXPECT_TRUE(index.isFlexible()); 1918 EXPECT_EQ(index.baseIndex(), kParamIndexNumbers | C2Param::BaseIndex::_kFlexibleFlag); 1919 EXPECT_EQ(index.paramIndex(), kParamIndexNumbers); 1920 1921 C2Param::Type type = C2NumbersStreamTuning::input::typeIndex; 1922 EXPECT_FALSE(type.isVendor()); 1923 EXPECT_TRUE(type.isFlexible()); 1924 EXPECT_FALSE(type.isGlobal()); 1925 EXPECT_TRUE(type.forInput()); 1926 EXPECT_FALSE(type.forOutput()); 1927 EXPECT_TRUE(type.forStream()); 1928 EXPECT_FALSE(type.forPort()); 1929 1930 type = C2NumbersStreamTuning::output::typeIndex; 1931 EXPECT_FALSE(type.isVendor()); 1932 EXPECT_TRUE(type.isFlexible()); 1933 EXPECT_FALSE(type.isGlobal()); 1934 EXPECT_FALSE(type.forInput()); 1935 EXPECT_TRUE(type.forOutput()); 1936 EXPECT_TRUE(type.forStream()); 1937 EXPECT_FALSE(type.forPort()); 1938 1939 EXPECT_EQ(C2NumbersPortTuning::From(nullptr), nullptr); 1940 EXPECT_EQ(C2NumbersPortTuning::input::From(nullptr), nullptr); 1941 EXPECT_EQ(C2NumbersPortTuning::output::From(nullptr), nullptr); 1942 EXPECT_EQ(C2NumbersTuning::From(ins1.get()), nullptr); 1943 EXPECT_EQ(C2NumbersTuning::From(ins2.get()), nullptr); 1944 EXPECT_EQ(C2NumbersTuning::From(outs1.get()), nullptr); 1945 EXPECT_EQ(C2NumbersTuning::From(outs2.get()), nullptr); 1946 EXPECT_EQ(C2NumbersPortTuning::From(ins1.get()), nullptr); 1947 EXPECT_EQ(C2NumbersPortTuning::From(ins2.get()), nullptr); 1948 EXPECT_EQ(C2NumbersPortTuning::From(outs1.get()), nullptr); 1949 EXPECT_EQ(C2NumbersPortTuning::From(outs2.get()), nullptr); 1950 EXPECT_EQ(C2NumbersPortTuning::input::From(ins1.get()), nullptr); 1951 EXPECT_EQ(C2NumbersPortTuning::input::From(ins2.get()), nullptr); 1952 EXPECT_EQ(C2NumbersPortTuning::input::From(outs1.get()), nullptr); 1953 EXPECT_EQ(C2NumbersPortTuning::input::From(outs2.get()), nullptr); 1954 EXPECT_EQ(C2NumbersPortTuning::output::From(ins1.get()), nullptr); 1955 EXPECT_EQ(C2NumbersPortTuning::output::From(ins2.get()), nullptr); 1956 EXPECT_EQ(C2NumbersPortTuning::output::From(outs1.get()), nullptr); 1957 EXPECT_EQ(C2NumbersPortTuning::output::From(outs2.get()), nullptr); 1958 EXPECT_EQ(C2NumbersStreamTuning::From(ins1.get()), ins1.get()); 1959 EXPECT_EQ(C2NumbersStreamTuning::From(ins2.get()), (C2NumbersStreamTuning*)ins2.get()); 1960 EXPECT_EQ(C2NumbersStreamTuning::From(outs1.get()), outs1.get()); 1961 EXPECT_EQ(C2NumbersStreamTuning::From(outs2.get()), (C2NumbersStreamTuning*)outs2.get()); 1962 EXPECT_EQ(C2NumbersStreamTuning::input::From(ins1.get()), (C2NumbersStreamTuning::input*)ins1.get()); 1963 EXPECT_EQ(C2NumbersStreamTuning::input::From(ins2.get()), ins2.get()); 1964 EXPECT_EQ(C2NumbersStreamTuning::input::From(outs1.get()), nullptr); 1965 EXPECT_EQ(C2NumbersStreamTuning::input::From(outs2.get()), nullptr); 1966 EXPECT_EQ(C2NumbersStreamTuning::output::From(ins1.get()), nullptr); 1967 EXPECT_EQ(C2NumbersStreamTuning::output::From(ins2.get()), nullptr); 1968 EXPECT_EQ(C2NumbersStreamTuning::output::From(outs1.get()), (C2NumbersStreamTuning::output*)outs1.get()); 1969 EXPECT_EQ(C2NumbersStreamTuning::output::From(outs2.get()), outs2.get()); 1970 1971 } 1972 1973 { 1974 C2Int32Value int32Value(INT32_MIN); 1975 static_assert(std::is_same<decltype(int32Value.mValue), int32_t>::value, "should be int32_t"); 1976 EXPECT_EQ(INT32_MIN, int32Value.mValue); 1977 std::list<const C2FieldDescriptor> fields = int32Value.fieldList; 1978 EXPECT_EQ(1u, fields.size()); 1979 EXPECT_EQ(FD::INT32, fields.cbegin()->type()); 1980 EXPECT_EQ(1u, fields.cbegin()->length()); 1981 EXPECT_EQ(C2String("value"), fields.cbegin()->name()); 1982 } 1983 1984 { 1985 C2Uint32Value uint32Value(UINT32_MAX); 1986 static_assert(std::is_same<decltype(uint32Value.mValue), uint32_t>::value, "should be uint32_t"); 1987 EXPECT_EQ(UINT32_MAX, uint32Value.mValue); 1988 std::list<const C2FieldDescriptor> fields = uint32Value.fieldList; 1989 EXPECT_EQ(1u, fields.size()); 1990 EXPECT_EQ(FD::UINT32, fields.cbegin()->type()); 1991 EXPECT_EQ(1u, fields.cbegin()->length()); 1992 EXPECT_EQ(C2String("value"), fields.cbegin()->name()); 1993 } 1994 1995 { 1996 C2Int64Value int64Value(INT64_MIN); 1997 static_assert(std::is_same<decltype(int64Value.mValue), int64_t>::value, "should be int64_t"); 1998 EXPECT_EQ(INT64_MIN, int64Value.mValue); 1999 std::list<const C2FieldDescriptor> fields = int64Value.fieldList; 2000 EXPECT_EQ(1u, fields.size()); 2001 EXPECT_EQ(FD::INT64, fields.cbegin()->type()); 2002 EXPECT_EQ(1u, fields.cbegin()->length()); 2003 EXPECT_EQ(C2String("value"), fields.cbegin()->name()); 2004 } 2005 2006 { 2007 C2Uint64Value uint64Value(UINT64_MAX); 2008 static_assert(std::is_same<decltype(uint64Value.mValue), uint64_t>::value, "should be uint64_t"); 2009 EXPECT_EQ(UINT64_MAX, uint64Value.mValue); 2010 std::list<const C2FieldDescriptor> fields = uint64Value.fieldList; 2011 EXPECT_EQ(1u, fields.size()); 2012 EXPECT_EQ(FD::UINT64, fields.cbegin()->type()); 2013 EXPECT_EQ(1u, fields.cbegin()->length()); 2014 EXPECT_EQ(C2String("value"), fields.cbegin()->name()); 2015 } 2016 2017 { 2018 C2FloatValue floatValue(123.4f); 2019 static_assert(std::is_same<decltype(floatValue.mValue), float>::value, "should be float"); 2020 EXPECT_EQ(123.4f, floatValue.mValue); 2021 std::list<const C2FieldDescriptor> fields = floatValue.fieldList; 2022 EXPECT_EQ(1u, fields.size()); 2023 EXPECT_EQ(FD::FLOAT, fields.cbegin()->type()); 2024 EXPECT_EQ(1u, fields.cbegin()->length()); 2025 EXPECT_EQ(C2String("value"), fields.cbegin()->name()); 2026 } 2027 2028 { 2029 uint8_t initValue[] = "ABCD"; 2030 typedef C2GlobalParam<C2Setting, C2BlobValue, 0> BlobSetting; 2031 std::unique_ptr<BlobSetting> blobValue = BlobSetting::alloc_unique(6, C2ConstMemoryBlock<uint8_t>(initValue)); 2032 static_assert(std::is_same<decltype(blobValue->m.mValue), uint8_t[]>::value, "should be uint8_t[]"); 2033 EXPECT_EQ(0, memcmp(blobValue->m.mValue, "ABCD\0", 6)); 2034 EXPECT_EQ(6u, blobValue->flexCount()); 2035 std::list<const C2FieldDescriptor> fields = blobValue->fieldList; 2036 EXPECT_EQ(1u, fields.size()); 2037 EXPECT_EQ(FD::BLOB, fields.cbegin()->type()); 2038 EXPECT_EQ(0u, fields.cbegin()->length()); 2039 EXPECT_EQ(C2String("value"), fields.cbegin()->name()); 2040 2041 blobValue = BlobSetting::alloc_unique(3, C2ConstMemoryBlock<uint8_t>(initValue)); 2042 EXPECT_EQ(0, memcmp(blobValue->m.mValue, "ABC", 3)); 2043 EXPECT_EQ(3u, blobValue->flexCount()); 2044 } 2045 2046 { 2047 constexpr char initValue[] = "ABCD"; 2048 typedef C2GlobalParam<C2Setting, C2StringValue, 0> StringSetting; 2049 std::unique_ptr<StringSetting> stringValue = StringSetting::alloc_unique(6, C2ConstMemoryBlock<char>(initValue)); 2050 stringValue = StringSetting::alloc_unique(6, initValue); 2051 static_assert(std::is_same<decltype(stringValue->m.mValue), char[]>::value, "should be char[]"); 2052 EXPECT_EQ(0, memcmp(stringValue->m.mValue, "ABCD\0", 6)); 2053 EXPECT_EQ(6u, stringValue->flexCount()); 2054 std::list<const C2FieldDescriptor> fields = stringValue->fieldList; 2055 EXPECT_EQ(1u, fields.size()); 2056 EXPECT_EQ(FD::STRING, fields.cbegin()->type()); 2057 EXPECT_EQ(0u, fields.cbegin()->length()); 2058 EXPECT_EQ(C2String("value"), fields.cbegin()->name()); 2059 2060 stringValue = StringSetting::alloc_unique(3, C2ConstMemoryBlock<char>(initValue)); 2061 EXPECT_EQ(0, memcmp(stringValue->m.mValue, "AB", 3)); 2062 EXPECT_EQ(3u, stringValue->flexCount()); 2063 2064 stringValue = StringSetting::alloc_unique(11, "initValue"); 2065 EXPECT_EQ(0, memcmp(stringValue->m.mValue, "initValue\0", 11)); 2066 EXPECT_EQ(11u, stringValue->flexCount()); 2067 2068 stringValue = StringSetting::alloc_unique(initValue); 2069 EXPECT_EQ(0, memcmp(stringValue->m.mValue, "ABCD", 5)); 2070 EXPECT_EQ(5u, stringValue->flexCount()); 2071 2072 stringValue = StringSetting::alloc_unique({ 'A', 'B', 'C', 'D' }); 2073 EXPECT_EQ(0, memcmp(stringValue->m.mValue, "ABC", 4)); 2074 EXPECT_EQ(4u, stringValue->flexCount()); 2075 } 2076 2077 { 2078 uint32_t videoWidth[] = { 12u, C2NumbersStreamTuning::output::typeIndex, 100 }; 2079 C2Param *p1 = C2Param::From(videoWidth, sizeof(videoWidth)); 2080 EXPECT_NE(nullptr, p1); 2081 EXPECT_EQ(12u, p1->size()); 2082 EXPECT_EQ(C2NumbersStreamTuning::output::typeIndex, p1->type()); 2083 2084 C2NumbersStreamTuning::output *vst = C2NumbersStreamTuning::output::From(p1); 2085 EXPECT_NE(nullptr, vst); 2086 if (vst) { 2087 EXPECT_EQ(1u, vst->flexCount()); 2088 EXPECT_EQ(100, vst->m.mNumbers[0]); 2089 } 2090 2091 p1 = C2Param::From(videoWidth, sizeof(videoWidth) + 2); 2092 EXPECT_EQ(nullptr, p1); 2093 2094 p1 = C2Param::From(videoWidth, sizeof(videoWidth) - 2); 2095 EXPECT_EQ(nullptr, p1); 2096 2097 p1 = C2Param::From(videoWidth, 3); 2098 EXPECT_EQ(nullptr, p1); 2099 2100 p1 = C2Param::From(videoWidth, 0); 2101 EXPECT_EQ(nullptr, p1); 2102 } 2103 2104 { 2105 uint32_t videoWidth[] = { 16u, C2NumbersPortTuning::input::typeIndex, 101, 102 }; 2106 2107 C2Param *p1 = C2Param::From(videoWidth, sizeof(videoWidth)); 2108 EXPECT_NE(nullptr, p1); 2109 EXPECT_EQ(16u, p1->size()); 2110 EXPECT_EQ(C2NumbersPortTuning::input::typeIndex, p1->type()); 2111 2112 C2NumbersPortTuning::input *vpt = C2NumbersPortTuning::input::From(p1); 2113 EXPECT_NE(nullptr, vpt); 2114 if (vpt) { 2115 EXPECT_EQ(2u, vpt->flexCount()); 2116 EXPECT_EQ(101, vpt->m.mNumbers[0]); 2117 EXPECT_EQ(102, vpt->m.mNumbers[1]); 2118 } 2119 2120 p1 = C2Param::From(videoWidth, sizeof(videoWidth) + 2); 2121 EXPECT_EQ(nullptr, p1); 2122 2123 p1 = C2Param::From(videoWidth, sizeof(videoWidth) - 2); 2124 EXPECT_EQ(nullptr, p1); 2125 2126 p1 = C2Param::From(videoWidth, 3); 2127 EXPECT_EQ(nullptr, p1); 2128 2129 p1 = C2Param::From(videoWidth, 0); 2130 EXPECT_EQ(nullptr, p1); 2131 } 2132} 2133 2134// *********************** 2135 2136} 2137 2138#include <util/C2ParamUtils.h> 2139#include <C2Config.h> 2140#include <C2Component.h> 2141#include <unordered_map> 2142 2143namespace android { 2144 2145C2ENUM( 2146 MetadataType, int32_t, 2147 kInvalid = -1, 2148 kNone = 0, 2149 kGralloc, 2150 kNativeHandle, 2151 kANativeWindow, 2152 kCamera, 2153) 2154 2155enum { 2156 kParamIndexVideoConfig = 0x1234, 2157}; 2158 2159struct C2VideoConfigStruct { 2160 int32_t mWidth; 2161 uint32_t mHeight; 2162 MetadataType mMetadataType; 2163 int32_t mSupportedFormats[]; 2164 2165 C2VideoConfigStruct() {} 2166 2167 DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(VideoConfig, mSupportedFormats) 2168 C2FIELD(mWidth, "width") 2169 C2FIELD(mHeight, "height") 2170 C2FIELD(mMetadataType, "metadata-type") 2171 C2FIELD(mSupportedFormats, "formats") 2172}; 2173 2174typedef C2PortParam<C2Tuning, C2VideoConfigStruct> C2VideoConfigPortTuning; 2175 2176class MyReflector : public C2ParamReflector { 2177private: 2178 std::unique_ptr<C2VideoConfigPortTuning::input> inputVideoConfigTuning; 2179 std::unique_ptr<C2VideoConfigPortTuning::output> outputVideoConfigTuning; 2180 2181public: 2182 void describeSupportedValues() { 2183 C2TypedFieldSupportedValues<int32_t> supportedWidths(16, 1920, 8); 2184 C2FieldSupportedValues supportedWidths2(16, 1920, 8); 2185 2186 2187 std::list<C2FieldSupportedValues> supported; 2188 //supported.emplace_push(inputVideoConfigTuning->mNumber, range(16, 1920, 8)); 2189 //supported.emplace_push(inputVideoConfigTuning->mHeight, range(16, 1088, 8)); 2190 //supported.emplace_push(inputVideoConfigTuning->mMetadataType, all_enums); 2191 //supported.emplace_push(inputVideoConfigTuning->mSupportedFormats, { 0, 1, 5, 7 }); 2192 } 2193 2194 virtual std::unique_ptr<android::C2StructDescriptor> describe(C2Param::BaseIndex paramType) { 2195 switch (paramType.baseIndex()) { 2196 case C2VideoConfigPortTuning::baseIndex: 2197 return std::unique_ptr<C2StructDescriptor>(new C2StructDescriptor{ 2198 paramType.baseIndex(), 2199 C2VideoConfigPortTuning::fieldList, 2200 }); 2201 } 2202 return nullptr; 2203 } 2204}; 2205 2206class MyComponentInstance : public C2ComponentInterface { 2207public: 2208 virtual C2String getName() const { 2209 /// \todo this seems too specific 2210 return "sample.interface"; 2211 }; 2212 2213 virtual node_id getId() const { 2214 /// \todo how are these shared? 2215 return 0; 2216 } 2217 2218 virtual status_t commit_sm( 2219 const std::vector<C2Param* const> ¶ms, 2220 std::vector<std::unique_ptr<C2SettingResult>>* const failures) { 2221 (void)params; 2222 (void)failures; 2223 return C2_UNSUPPORTED; 2224 } 2225 2226 virtual status_t config_nb( 2227 const std::vector<C2Param* const> ¶ms, 2228 std::vector<std::unique_ptr<C2SettingResult>>* const failures) { 2229 (void)params; 2230 (void)failures; 2231 return C2_UNSUPPORTED; 2232 } 2233 2234 virtual status_t createTunnel_sm(node_id targetComponent) { 2235 (void)targetComponent; 2236 return C2_UNSUPPORTED; 2237 } 2238 2239 virtual status_t query_nb( 2240 const std::vector<C2Param* const> &stackParams, 2241 const std::vector<C2Param::Index> &heapParamIndices, 2242 std::vector<std::unique_ptr<C2Param>>* const heapParams) const { 2243 for (C2Param* const param : stackParams) { 2244 if (!*param) { // param is already invalid - remember it 2245 continue; 2246 } 2247 2248 // note: this does not handle stream params (should use index...) 2249 if (!mMyParams.count(param->type())) { 2250 continue; // not my param 2251 } 2252 2253 C2Param & myParam = mMyParams.find(param->type())->second; 2254 if (myParam.size() != param->size()) { // incorrect size 2255 param->invalidate(); 2256 continue; 2257 } 2258 2259 param->updateFrom(myParam); 2260 } 2261 2262 for (const C2Param::Index index : heapParamIndices) { 2263 if (mMyParams.count(index)) { 2264 C2Param & myParam = mMyParams.find(index)->second; 2265 std::unique_ptr<C2Param> paramCopy(C2Param::From(&myParam, myParam.size())); 2266 heapParams->push_back(std::move(paramCopy)); 2267 } 2268 } 2269 2270 return C2_OK; 2271 } 2272 2273 std::unordered_map<uint32_t, C2Param &> mMyParams; 2274 2275 C2ComponentDomainInfo mDomainInfo; 2276 2277 MyComponentInstance() { 2278 mMyParams.insert({mDomainInfo.type(), mDomainInfo}); 2279 } 2280 2281 virtual status_t releaseTunnel_sm(node_id targetComponent) { 2282 (void)targetComponent; 2283 return C2_UNSUPPORTED; 2284 } 2285 2286 class MyParamReflector : public C2ParamReflector { 2287 const MyComponentInstance *instance; 2288 2289 public: 2290 MyParamReflector(const MyComponentInstance *i) : instance(i) { } 2291 2292 virtual std::unique_ptr<C2StructDescriptor> describe(C2Param::BaseIndex paramIndex) { 2293 switch (paramIndex.baseIndex()) { 2294 case decltype(instance->mDomainInfo)::baseIndex: 2295 default: 2296 return std::unique_ptr<C2StructDescriptor>(new C2StructDescriptor{ 2297 instance->mDomainInfo.type(), 2298 decltype(instance->mDomainInfo)::fieldList, 2299 }); 2300 } 2301 return nullptr; 2302 } 2303 }; 2304 2305 virtual status_t getSupportedValues( 2306 const std::vector<const C2ParamField> fields, 2307 std::vector<C2FieldSupportedValues>* const values) const { 2308 for (const C2ParamField &field : fields) { 2309 if (field == C2ParamField(&mDomainInfo, &C2ComponentDomainInfo::mValue)) { 2310 values->push_back(C2FieldSupportedValues( 2311 false /* flag */, 2312 &mDomainInfo.mValue 2313 //, 2314 //{(int32_t)C2DomainVideo} 2315 )); 2316 } 2317 } 2318 return C2_OK; 2319 } 2320 2321 virtual std::shared_ptr<C2ParamReflector> getParamReflector() const { 2322 return std::shared_ptr<C2ParamReflector>(new MyParamReflector(this)); 2323 } 2324 2325 virtual status_t getSupportedParams(std::vector<std::shared_ptr<C2ParamDescriptor>> * const params) const { 2326 params->push_back(std::make_shared<C2ParamDescriptor>( 2327 true /* required */, "_domain", &mDomainInfo)); 2328 return C2_OK; 2329 } 2330 2331 status_t getSupportedParams2(std::vector<std::shared_ptr<C2ParamDescriptor>> * const params) { 2332 params->push_back(std::shared_ptr<C2ParamDescriptor>( 2333 new C2ParamDescriptor(true /* required */, "_domain", &mDomainInfo))); 2334 return C2_OK; 2335 } 2336 2337}; 2338 2339template<typename E, bool S=std::is_enum<E>::value> 2340struct getter { 2341 int32_t get(const C2FieldSupportedValues::Primitive &p, int32_t*) { 2342 return p.i32; 2343 } 2344 int64_t get(const C2FieldSupportedValues::Primitive &p, int64_t*) { 2345 return p.i64; 2346 } 2347 uint32_t get(const C2FieldSupportedValues::Primitive &p, uint32_t*) { 2348 return p.u32; 2349 } 2350 uint64_t get(const C2FieldSupportedValues::Primitive &p, uint64_t*) { 2351 return p.u64; 2352 } 2353 float get(const C2FieldSupportedValues::Primitive &p, float*) { 2354 return p.fp; 2355 } 2356}; 2357 2358template<typename E> 2359struct getter<E, true> { 2360 typename std::underlying_type<E>::type get(const C2FieldSupportedValues::Primitive &p, E*) { 2361 using u=typename std::underlying_type<E>::type; 2362 return getter<u>().get(p, (u*)0); 2363 } 2364}; 2365 2366template<typename T, bool E=std::is_enum<T>::value> 2367struct lax_underlying_type { 2368 typedef typename std::underlying_type<T>::type type; 2369}; 2370 2371template<typename T> 2372struct lax_underlying_type<T, false> { 2373 typedef T type; 2374}; 2375 2376template<typename E> 2377typename lax_underlying_type<E>::type get( 2378 const C2FieldSupportedValues::Primitive &p, E*) { 2379 return getter<E>().get(p, (E*)0); 2380} 2381 2382template<typename T> 2383void dumpFSV(const C2FieldSupportedValues &sv, T*t) { 2384 using namespace std; 2385 cout << (std::is_enum<T>::value ? (std::is_signed<typename std::underlying_type<T>::type>::value ? "i" : "u") 2386 : std::is_integral<T>::value ? std::is_signed<T>::value ? "i" : "u" : "f") 2387 << (8 * sizeof(T)); 2388 if (sv.type == sv.RANGE) { 2389 cout << ".range(" << get(sv.range.min, t); 2390 if (get(sv.range.step, t) != std::is_integral<T>::value) { 2391 cout << ":" << get(sv.range.step, t); 2392 } 2393 if (get(sv.range.nom, t) != 1 || get(sv.range.denom, t) != 1) { 2394 cout << ":" << get(sv.range.nom, t) << "/" << get(sv.range.denom, t); 2395 } 2396 cout << get(sv.range.max, t) << ")"; 2397 } 2398 if (sv.values.size()) { 2399 cout << (sv.type == sv.FLAGS ? ".flags(" : ".list("); 2400 const char *sep = ""; 2401 for (const C2FieldSupportedValues::Primitive &p : sv.values) { 2402 cout << sep << get(p, t); 2403 sep = ","; 2404 } 2405 cout << ")"; 2406 } 2407 cout << endl; 2408} 2409 2410void dumpType(C2Param::Type type) { 2411 using namespace std; 2412 cout << (type.isVendor() ? "Vendor" : "C2"); 2413 if (type.forInput()) { 2414 cout << "Input"; 2415 } else if (type.forOutput()) { 2416 cout << "Output"; 2417 } else if (type.forPort() && !type.forStream()) { 2418 cout << "Port"; 2419 } 2420 if (type.forStream()) { 2421 cout << "Stream"; 2422 } 2423 2424 if (type.isFlexible()) { 2425 cout << "Flex"; 2426 } 2427 2428 cout << type.paramIndex(); 2429 2430 switch (type.kind()) { 2431 case C2Param::INFO: cout << "Info"; break; 2432 case C2Param::SETTING: cout << "Setting"; break; 2433 case C2Param::TUNING: cout << "Tuning"; break; 2434 case C2Param::STRUCT: cout << "Struct"; break; 2435 default: cout << "Kind" << (int32_t)type.kind(); break; 2436 } 2437} 2438 2439void dumpType(C2Param::BaseIndex type) { 2440 using namespace std; 2441 cout << (type.isVendor() ? "Vendor" : "C2"); 2442 if (type.isFlexible()) { 2443 cout << "Flex"; 2444 } 2445 2446 cout << type.paramIndex() << "Struct"; 2447} 2448 2449void dumpType(FD::Type type) { 2450 using namespace std; 2451 switch (type) { 2452 case FD::BLOB: cout << "blob "; break; 2453 case FD::FLOAT: cout << "float "; break; 2454 case FD::INT32: cout << "int32_t "; break; 2455 case FD::INT64: cout << "int64_t "; break; 2456 case FD::UINT32: cout << "uint32_t "; break; 2457 case FD::UINT64: cout << "uint64_t "; break; 2458 case FD::STRING: cout << "char "; break; 2459 default: 2460 cout << "struct "; 2461 dumpType((C2Param::Type)type); 2462 break; 2463 } 2464} 2465 2466void dumpStruct(const C2StructDescriptor &sd) { 2467 using namespace std; 2468 cout << "struct "; 2469 dumpType(sd.baseIndex()); 2470 cout << " {" << endl; 2471 //C2FieldDescriptor &f; 2472 for (const C2FieldDescriptor &f : sd) { 2473 PrintTo(f, &cout); 2474 cout << endl; 2475 2476 if (f.namedValues().size()) { 2477 cout << ".named("; 2478 const char *sep = ""; 2479 for (const FD::named_value_type &p : f.namedValues()) { 2480 cout << sep << p.first << "="; 2481 switch (f.type()) { 2482 case C2Value::INT32: cout << get(p.second, (int32_t *)0); break; 2483 case C2Value::INT64: cout << get(p.second, (int64_t *)0); break; 2484 case C2Value::UINT32: cout << get(p.second, (uint32_t *)0); break; 2485 case C2Value::UINT64: cout << get(p.second, (uint64_t *)0); break; 2486 case C2Value::FLOAT: cout << get(p.second, (float *)0); break; 2487 default: cout << "???"; break; 2488 } 2489 sep = ","; 2490 } 2491 cout << ")"; 2492 } 2493 } 2494 2495 cout << "};" << endl; 2496} 2497 2498void dumpDesc(const C2ParamDescriptor &pd) { 2499 using namespace std; 2500 if (pd.isRequired()) { 2501 cout << "required "; 2502 } 2503 if (pd.isPersistent()) { 2504 cout << "persistent "; 2505 } 2506 cout << "struct "; 2507 dumpType(pd.type()); 2508 cout << " " << pd.name() << ";" << endl; 2509} 2510 2511TEST_F(C2ParamTest, ReflectorTest) { 2512 C2ComponentDomainInfo domainInfo; 2513 std::shared_ptr<C2ComponentInterface> comp(new MyComponentInstance); 2514 std::vector<C2FieldSupportedValues> values; 2515 2516 std::unique_ptr<C2StructDescriptor> desc{ 2517 comp->getParamReflector()->describe(C2ComponentDomainInfo::indexFlags)}; 2518 dumpStruct(*desc); 2519 2520 EXPECT_EQ( 2521 C2_OK, 2522 comp->getSupportedValues( 2523 { C2ParamField(&domainInfo, &C2ComponentDomainInfo::mValue) }, 2524 &values) 2525 ); 2526 2527 for (const C2FieldSupportedValues &sv : values) { 2528 dumpFSV(sv, &domainInfo.mValue); 2529 } 2530} 2531 2532C2ENUM(Enum1, uint32_t, 2533 Enum1Value1, 2534 Enum1Value2, 2535 Enum1Value4 = Enum1Value2 + 2, 2536); 2537 2538C2ENUM_CUSTOM_PREFIX(Enum2, uint32_t, "Enum", 2539 Enum2Value1, 2540 Enum2Value2, 2541 Enum2Value4 = Enum1Value2 + 2, 2542); 2543 2544C2ENUM_CUSTOM_NAMES(Enum3, uint8_t, 2545 ({ { "value1", Enum3Value1 }, 2546 { "value2", Enum3Value2 }, 2547 { "value4", Enum3Value4 }, 2548 { "invalid", Invalid } }), 2549 Enum3Value1, 2550 Enum3Value2, 2551 Enum3Value4 = Enum3Value2 + 2, 2552 Invalid, 2553); 2554 2555TEST_F(C2ParamTest, EnumUtilsTest) { 2556 std::vector<std::pair<C2String, Enum3>> pairs ( { { "value1", Enum3Value1 }, 2557 { "value2", Enum3Value2 }, 2558 { "value4", Enum3Value4 }, 2559 { "invalid", Invalid } }); 2560 Enum3 e3; 2561 FD::namedValuesFor(e3); 2562} 2563 2564TEST_F(C2ParamTest, ParamUtilsTest) { 2565 // upper case 2566 EXPECT_EQ("yes", C2ParamUtils::camelCaseToDashed("YES")); 2567 EXPECT_EQ("no", C2ParamUtils::camelCaseToDashed("NO")); 2568 EXPECT_EQ("yes-no", C2ParamUtils::camelCaseToDashed("YES_NO")); 2569 EXPECT_EQ("yes-no", C2ParamUtils::camelCaseToDashed("YES__NO")); 2570 EXPECT_EQ("a2dp", C2ParamUtils::camelCaseToDashed("A2DP")); 2571 EXPECT_EQ("mp2-ts", C2ParamUtils::camelCaseToDashed("MP2_TS")); 2572 EXPECT_EQ("block-2d", C2ParamUtils::camelCaseToDashed("BLOCK_2D")); 2573 EXPECT_EQ("mpeg-2-ts", C2ParamUtils::camelCaseToDashed("MPEG_2_TS")); 2574 EXPECT_EQ("_hidden-value", C2ParamUtils::camelCaseToDashed("_HIDDEN_VALUE")); 2575 EXPECT_EQ("__hidden-value2", C2ParamUtils::camelCaseToDashed("__HIDDEN_VALUE2")); 2576 EXPECT_EQ("__hidden-value-2", C2ParamUtils::camelCaseToDashed("__HIDDEN_VALUE_2")); 2577 2578 // camel case 2579 EXPECT_EQ("yes", C2ParamUtils::camelCaseToDashed("Yes")); 2580 EXPECT_EQ("no", C2ParamUtils::camelCaseToDashed("No")); 2581 EXPECT_EQ("yes-no", C2ParamUtils::camelCaseToDashed("YesNo")); 2582 EXPECT_EQ("yes-no", C2ParamUtils::camelCaseToDashed("Yes_No")); 2583 EXPECT_EQ("mp2-ts", C2ParamUtils::camelCaseToDashed("MP2Ts")); 2584 EXPECT_EQ("block-2d", C2ParamUtils::camelCaseToDashed("Block2D")); 2585 EXPECT_EQ("mpeg-2-ts", C2ParamUtils::camelCaseToDashed("Mpeg2ts")); 2586 EXPECT_EQ("_hidden-value", C2ParamUtils::camelCaseToDashed("_HiddenValue")); 2587 EXPECT_EQ("__hidden-value-2", C2ParamUtils::camelCaseToDashed("__HiddenValue2")); 2588 2589 // mixed case 2590 EXPECT_EQ("mp2t-s", C2ParamUtils::camelCaseToDashed("MP2T_s")); 2591 EXPECT_EQ("block-2d", C2ParamUtils::camelCaseToDashed("Block_2D")); 2592 EXPECT_EQ("block-2-d", C2ParamUtils::camelCaseToDashed("Block2_D")); 2593 EXPECT_EQ("mpeg-2-ts", C2ParamUtils::camelCaseToDashed("Mpeg_2ts")); 2594 EXPECT_EQ("mpeg-2-ts", C2ParamUtils::camelCaseToDashed("Mpeg_2_TS")); 2595 EXPECT_EQ("_hidden-value", C2ParamUtils::camelCaseToDashed("_Hidden__VALUE")); 2596 EXPECT_EQ("__hidden-value-2", C2ParamUtils::camelCaseToDashed("__HiddenValue_2")); 2597 EXPECT_EQ("_2", C2ParamUtils::camelCaseToDashed("_2")); 2598 EXPECT_EQ("__23", C2ParamUtils::camelCaseToDashed("__23")); 2599} 2600 2601TEST_F(C2ParamTest, C2ValueTest) { 2602 C2Value val; 2603 int32_t i32 = -32; 2604 int64_t i64 = -64; 2605 uint32_t u32 = 32; 2606 uint64_t u64 = 64; 2607 float fp = 1.5f; 2608 2609 EXPECT_EQ(C2Value::NO_INIT, val.type()); 2610 EXPECT_EQ(false, val.get(&i32)); 2611 EXPECT_EQ(-32, i32); 2612 EXPECT_EQ(false, val.get(&i64)); 2613 EXPECT_EQ(-64, i64); 2614 EXPECT_EQ(false, val.get(&u32)); 2615 EXPECT_EQ(32u, u32); 2616 EXPECT_EQ(false, val.get(&u64)); 2617 EXPECT_EQ(64u, u64); 2618 EXPECT_EQ(false, val.get(&fp)); 2619 EXPECT_EQ(1.5f, fp); 2620 2621 val = int32_t(-3216); 2622 EXPECT_EQ(C2Value::INT32, val.type()); 2623 EXPECT_EQ(true, val.get(&i32)); 2624 EXPECT_EQ(-3216, i32); 2625 EXPECT_EQ(false, val.get(&i64)); 2626 EXPECT_EQ(-64, i64); 2627 EXPECT_EQ(false, val.get(&u32)); 2628 EXPECT_EQ(32u, u32); 2629 EXPECT_EQ(false, val.get(&u64)); 2630 EXPECT_EQ(64u, u64); 2631 EXPECT_EQ(false, val.get(&fp)); 2632 EXPECT_EQ(1.5f, fp); 2633 2634 val = uint32_t(3216); 2635 EXPECT_EQ(C2Value::UINT32, val.type()); 2636 EXPECT_EQ(false, val.get(&i32)); 2637 EXPECT_EQ(-3216, i32); 2638 EXPECT_EQ(false, val.get(&i64)); 2639 EXPECT_EQ(-64, i64); 2640 EXPECT_EQ(true, val.get(&u32)); 2641 EXPECT_EQ(3216u, u32); 2642 EXPECT_EQ(false, val.get(&u64)); 2643 EXPECT_EQ(64u, u64); 2644 EXPECT_EQ(false, val.get(&fp)); 2645 EXPECT_EQ(1.5f, fp); 2646 2647 val = int64_t(-6432); 2648 EXPECT_EQ(C2Value::INT64, val.type()); 2649 EXPECT_EQ(false, val.get(&i32)); 2650 EXPECT_EQ(-3216, i32); 2651 EXPECT_EQ(true, val.get(&i64)); 2652 EXPECT_EQ(-6432, i64); 2653 EXPECT_EQ(false, val.get(&u32)); 2654 EXPECT_EQ(3216u, u32); 2655 EXPECT_EQ(false, val.get(&u64)); 2656 EXPECT_EQ(64u, u64); 2657 EXPECT_EQ(false, val.get(&fp)); 2658 EXPECT_EQ(1.5f, fp); 2659 2660 val = uint64_t(6432); 2661 EXPECT_EQ(C2Value::UINT64, val.type()); 2662 EXPECT_EQ(false, val.get(&i32)); 2663 EXPECT_EQ(-3216, i32); 2664 EXPECT_EQ(false, val.get(&i64)); 2665 EXPECT_EQ(-6432, i64); 2666 EXPECT_EQ(false, val.get(&u32)); 2667 EXPECT_EQ(3216u, u32); 2668 EXPECT_EQ(true, val.get(&u64)); 2669 EXPECT_EQ(6432u, u64); 2670 EXPECT_EQ(false, val.get(&fp)); 2671 EXPECT_EQ(1.5f, fp); 2672 2673 val = 15.25f; 2674 EXPECT_EQ(C2Value::FLOAT, val.type()); 2675 EXPECT_EQ(false, val.get(&i32)); 2676 EXPECT_EQ(-3216, i32); 2677 EXPECT_EQ(false, val.get(&i64)); 2678 EXPECT_EQ(-6432, i64); 2679 EXPECT_EQ(false, val.get(&u32)); 2680 EXPECT_EQ(3216u, u32); 2681 EXPECT_EQ(false, val.get(&u64)); 2682 EXPECT_EQ(6432u, u64); 2683 EXPECT_EQ(true, val.get(&fp)); 2684 EXPECT_EQ(15.25f, fp); 2685} 2686 2687} // namespace android 2688