/*
 * Copyright 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//#define LOG_NDEBUG 0
#define LOG_TAG "C2Param_test"

#include <gtest/gtest.h>

#define __C2_GENERATE_GLOBAL_VARS__
#include <C2ParamDef.h>

#include <list>

void PrintTo(const _C2FieldId &id, ::std::ostream* os) {
    *os << "@" << id._mOffset << "+" << id._mSize;
}

void PrintTo(const C2FieldDescriptor &fd, ::std::ostream *os) {
    using FD=C2FieldDescriptor;
    switch (fd.type()) {
    case FD::INT32: *os << "i32"; break;
    case FD::INT64: *os << "i64"; break;
    case FD::UINT32: *os << "u32"; break;
    case FD::UINT64: *os << "u64"; break;
    case FD::FLOAT: *os << "float"; break;
    case FD::STRING: *os << "char"; break;
    case FD::BLOB: *os << "u8"; break;
    default:
        if (fd.type() & FD::STRUCT_FLAG) {
            *os << "struct-" << (fd.type() & ~FD::STRUCT_FLAG);
        } else {
            *os << "type-" << fd.type();
        }
    }
    *os << " " << fd.name();
    if (fd.extent() > 1) {
        *os << "[" << fd.extent() << "]";
    } else if (fd.extent() == 0) {
        *os << "[]";
    }
    *os << " (";
    PrintTo(fd._mFieldId, os);
    *os << "*" << fd.extent() << ")";
}

enum C2ParamIndexType : C2Param::type_index_t {
    kParamIndexNumber,
    kParamIndexNumbers,
    kParamIndexNumber2,
    kParamIndexVendorStart = C2Param::TYPE_INDEX_VENDOR_START,
    kParamIndexVendorNumbers,
};

void ffff(int(*)(int)) {}

/* ============================= STRUCT DECLARATION AND DESCRIPTION ============================= */

typedef C2FieldDescriptor FD;

class C2ParamTest : public ::testing::Test {
};

class C2ParamTest_ParamFieldList
        : public ::testing::TestWithParam<std::vector<C2FieldDescriptor>> {
};

enum {
    kParamIndexSize,
    kParamIndexTestA,
    kParamIndexTestB,
    kParamIndexTestFlexS32,
    kParamIndexTestFlexEndS32,
    kParamIndexTestFlexS64,
    kParamIndexTestFlexEndS64,
    kParamIndexTestFlexSize,
    kParamIndexTestFlexEndSize,
};

struct C2SizeStruct {
    int32_t width;
    int32_t height;
    enum : uint32_t { CORE_INDEX = kParamIndexSize };                        // <= needed for C2FieldDescriptor
    const static std::vector<C2FieldDescriptor> _FIELD_LIST;
    static const std::vector<C2FieldDescriptor> FieldList();  // <= needed for C2FieldDescriptor
    const static FD::type_t TYPE = (FD::type_t)(CORE_INDEX | FD::STRUCT_FLAG);
};

DEFINE_NO_NAMED_VALUES_FOR(C2SizeStruct)

// Test 1. define a structure without any helper methods

bool operator==(const C2FieldDescriptor &a, const C2FieldDescriptor &b) {
    return a.type() == b.type()
            && a.extent() == b.extent()
            && a.name() == b.name()
            && a._mFieldId == b._mFieldId;
}

struct C2TestStruct_A {
    int32_t signed32;
    int64_t signed64[2];
    uint32_t unsigned32[1];
    uint64_t unsigned64;
    float fp32;
    C2SizeStruct sz[3];
    uint8_t blob[100];
    char string[100];
    bool yesNo[100];

    const static std::vector<C2FieldDescriptor> _FIELD_LIST;
    static const std::vector<C2FieldDescriptor> FieldList();
    // enum : uint32_t { CORE_INDEX = kParamIndexTest };
    // typedef C2TestStruct_A _type;
} __attribute__((packed));

const std::vector<C2FieldDescriptor> C2TestStruct_A::FieldList() {
    return _FIELD_LIST;
}
const std::vector<C2FieldDescriptor> C2TestStruct_A::_FIELD_LIST =
    { { FD::INT32,    1, "s32",   0, 4 },
      { FD::INT64,    2, "s64",   4, 8 },
      { FD::UINT32,   1, "u32",  20, 4 },
      { FD::UINT64,   1, "u64",  24, 8 },
      { FD::FLOAT,    1, "fp",   32, 4 },
      { C2SizeStruct::TYPE, 3, "size", 36, 8 },
      { FD::BLOB,   100, "blob", 60, 1 },
      { FD::STRING, 100, "str", 160, 1 },
      { FD::BLOB,   100, "y-n", 260, 1 } };

TEST_P(C2ParamTest_ParamFieldList, VerifyStruct) {
    std::vector<C2FieldDescriptor> fields = GetParam(), expected = C2TestStruct_A::_FIELD_LIST;

    // verify first field descriptor
    EXPECT_EQ(FD::INT32, fields[0].type());
    EXPECT_STREQ("s32", fields[0].name().c_str());
    EXPECT_EQ(1u, fields[0].extent());
    EXPECT_EQ(_C2FieldId(0, 4), fields[0]._mFieldId);

    EXPECT_EQ(expected[0], fields[0]);
    EXPECT_EQ(expected[1], fields[1]);
    EXPECT_EQ(expected[2], fields[2]);
    EXPECT_EQ(expected[3], fields[3]);
    EXPECT_EQ(expected[4], fields[4]);
    EXPECT_EQ(expected[5], fields[5]);
    EXPECT_EQ(expected[6], fields[6]);
    EXPECT_EQ(expected[7], fields[7]);
    for (size_t i = 8; i < fields.size() && i < expected.size(); ++i) {
        EXPECT_EQ(expected[i], fields[i]);
    }
}

INSTANTIATE_TEST_CASE_P(InitializerList, C2ParamTest_ParamFieldList, ::testing::Values(C2TestStruct_A::_FIELD_LIST));

// define fields using C2FieldDescriptor pointer constructor
const std::vector<C2FieldDescriptor> C2TestStruct_A_FD_PTR_fieldList =
    { C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->signed32,   "s32"),
      C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->signed64,   "s64"),
      C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->unsigned32, "u32"),
      C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->unsigned64, "u64"),
      C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->fp32,      "fp"),
      C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->sz,       "size"),
      C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->blob,       "blob"),
      C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->string,     "str"),
    //  C2FieldDescriptor(&((C2TestStruct_A*)(nullptr))->yesNo,      "y-n")
    };

INSTANTIATE_TEST_CASE_P(PointerConstructor, C2ParamTest_ParamFieldList, ::testing::Values(C2TestStruct_A_FD_PTR_fieldList));

// define fields using C2FieldDescriptor member-pointer constructor
const std::vector<C2FieldDescriptor> C2TestStruct_A_FD_MEM_PTR_fieldList =
    { C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::signed32,   "s32"),
      C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::signed64,   "s64"),
      C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::unsigned32, "u32"),
      C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::unsigned64, "u64"),
      C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::fp32,      "fp"),
      C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::sz,       "size"),
      C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::blob,       "blob"),
      C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::string,     "str"),
    //  C2FieldDescriptor((C2TestStruct_A*)0, &C2TestStruct_A::yesNo,      "y-n")
    };

INSTANTIATE_TEST_CASE_P(MemberPointerConstructor, C2ParamTest_ParamFieldList, ::testing::Values(C2TestStruct_A_FD_MEM_PTR_fieldList));

// Test 2. define a structure with two-step helper methods

struct C2TestAStruct {
    int32_t signed32;
    int64_t signed64[2];
    uint32_t unsigned32[1];
    uint64_t unsigned64;
    float fp32;
    C2SizeStruct sz[3];
    uint8_t blob[100];
    char string[100];
    bool yesNo[100];

private: // test access level
    DEFINE_C2STRUCT(TestA)
} C2_PACK;

DESCRIBE_C2STRUCT(TestA, {
    C2FIELD(signed32, "s32")
    C2FIELD(signed64, "s64")
    C2FIELD(unsigned32, "u32")
    C2FIELD(unsigned64, "u64")
    C2FIELD(fp32, "fp")
    C2FIELD(sz, "size")
    C2FIELD(blob, "blob")
    C2FIELD(string, "str")
    // C2FIELD(yesNo, "y-n")
}) // ; optional

INSTANTIATE_TEST_CASE_P(DescribeStruct2Step, C2ParamTest_ParamFieldList, ::testing::Values(C2TestAStruct::FieldList()));

// Test 3. define a structure with one-step helper method

struct C2TestBStruct {
    int32_t signed32;
    int64_t signed64[2];
    uint32_t unsigned32[1];
    uint64_t unsigned64;
    float fp32;
    C2SizeStruct sz[3];
    uint8_t blob[100];
    char string[100];
    bool yesNo[100];

private: // test access level
    DEFINE_AND_DESCRIBE_C2STRUCT(TestB)

    C2FIELD(signed32, "s32")
    C2FIELD(signed64, "s64")
    C2FIELD(unsigned32, "u32")
    C2FIELD(unsigned64, "u64")
    C2FIELD(fp32, "fp")
    C2FIELD(sz, "size")
    C2FIELD(blob, "blob")
    C2FIELD(string, "str")
    // C2FIELD(yesNo, "y-n")
};

INSTANTIATE_TEST_CASE_P(DescribeStruct1Step, C2ParamTest_ParamFieldList, ::testing::Values(C2TestBStruct::FieldList()));

// Test 4. flexible members

template<typename T>
class C2ParamTest_FlexParamFieldList : public ::testing::Test {
protected:
    using type_t=FD::type_t;

    // static std::vector<std::vector<C2FieldDescriptor>>
    static std::vector<std::vector<C2FieldDescriptor>>
            GetLists();

    constexpr static type_t FlexType =
            std::is_same<T, int32_t>::value ? FD::INT32 :
            std::is_same<T, int64_t>::value ? FD::INT64 :
            std::is_same<T, uint32_t>::value ? FD::UINT32 :
            std::is_same<T, uint64_t>::value ? FD::UINT64 :
            std::is_same<T, float>::value ? FD::FLOAT :
            std::is_same<T, uint8_t>::value ? FD::BLOB :
            std::is_same<T, char>::value ? FD::STRING :
            std::is_same<T, C2SizeStruct>::value ? C2SizeStruct::TYPE : (type_t)0;
    constexpr static size_t FLEX_SIZE = sizeof(T);
};

typedef ::testing::Types<int32_t, int64_t, C2SizeStruct> FlexTypes;
TYPED_TEST_CASE(C2ParamTest_FlexParamFieldList, FlexTypes);

TYPED_TEST(C2ParamTest_FlexParamFieldList, VerifyStruct) {
    for (auto a : this->GetLists()) {
        std::vector<C2FieldDescriptor> fields = a;
        if (fields.size() > 1) {
            EXPECT_EQ(2u, fields.size());
            EXPECT_EQ(C2FieldDescriptor(FD::INT32, 1, "s32", 0, 4), fields[0]);
            EXPECT_EQ(C2FieldDescriptor(this->FlexType, 0, "flex", 4, this->FLEX_SIZE),
                      fields[1]);
        } else {
            EXPECT_EQ(1u, fields.size());
            EXPECT_EQ(C2FieldDescriptor(this->FlexType, 0, "flex", 0, this->FLEX_SIZE),
                      fields[0]);
        }
    }
}

struct C2TestStruct_FlexS32 {
    int32_t mFlex[];

    const static std::vector<C2FieldDescriptor> _FIELD_LIST;
    static const std::vector<C2FieldDescriptor> FieldList();
    // enum : uint32_t { CORE_INDEX = kParamIndexTestFlex, FLEX_SIZE = 4 };
    // typedef C2TestStruct_FlexS32 _type;
    // typedef int32_t FlexType;
};

const std::vector<C2FieldDescriptor> C2TestStruct_FlexS32::FieldList() {
    return _FIELD_LIST;
}
const std::vector<C2FieldDescriptor> C2TestStruct_FlexS32::_FIELD_LIST = {
    { FD::INT32, 0, "flex", 0, 4 }
};

struct C2TestStruct_FlexEndS32 {
    int32_t signed32;
    int32_t mFlex[];

    const static std::vector<C2FieldDescriptor> _FIELD_LIST;
    static const std::vector<C2FieldDescriptor> FieldList();
    // enum : uint32_t { CORE_INDEX = kParamIndexTestFlexEnd, FLEX_SIZE = 4 };
    // typedef C2TestStruct_FlexEnd _type;
    // typedef int32_t FlexType;
};

const std::vector<C2FieldDescriptor> C2TestStruct_FlexEndS32::FieldList() {
    return _FIELD_LIST;
}
const std::vector<C2FieldDescriptor> C2TestStruct_FlexEndS32::_FIELD_LIST = {
    { FD::INT32, 1, "s32", 0, 4 },
    { FD::INT32, 0, "flex", 4, 4 },
};

const static std::vector<C2FieldDescriptor> C2TestStruct_FlexEndS32_ptr_fieldList = {
    C2FieldDescriptor(&((C2TestStruct_FlexEndS32*)0)->signed32, "s32"),
    C2FieldDescriptor(&((C2TestStruct_FlexEndS32*)0)->mFlex, "flex"),
};

struct C2TestFlexS32Struct {
    int32_t mFlexSigned32[];
private: // test access level
    C2TestFlexS32Struct() {}

    DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(TestFlexS32, mFlexSigned32)
    C2FIELD(mFlexSigned32, "flex")
};

struct C2TestFlexEndS32Struct {
    int32_t signed32;
    int32_t mFlexSigned32[];
private: // test access level
    C2TestFlexEndS32Struct() {}

    DEFINE_FLEX_C2STRUCT(TestFlexEndS32, mFlexSigned32)
} C2_PACK;

DESCRIBE_C2STRUCT(TestFlexEndS32, {
    C2FIELD(signed32, "s32")
    C2FIELD(mFlexSigned32, "flex")
}) // ; optional

template<>
std::vector<std::vector<C2FieldDescriptor>>
//std::vector<std::vector<C2FieldDescriptor>>
C2ParamTest_FlexParamFieldList<int32_t>::GetLists() {
    return {
        C2TestStruct_FlexS32::FieldList(),
        C2TestStruct_FlexEndS32::FieldList(),
        C2TestStruct_FlexEndS32_ptr_fieldList,
        C2TestFlexS32Struct::FieldList(),
        C2TestFlexEndS32Struct::FieldList(),
    };
}

struct C2TestStruct_FlexS64 {
    int64_t mFlexSigned64[];

    const static std::vector<C2FieldDescriptor> _FIELD_LIST;
    static const std::vector<C2FieldDescriptor> FieldList();
    // enum : uint32_t { CORE_INDEX = kParamIndexTestFlexS64, FLEX_SIZE = 8 };
    // typedef C2TestStruct_FlexS64 _type;
    // typedef int64_t FlexType;
};

const std::vector<C2FieldDescriptor> C2TestStruct_FlexS64::FieldList() {
    return _FIELD_LIST;
}
const std::vector<C2FieldDescriptor> C2TestStruct_FlexS64::_FIELD_LIST = {
    { FD::INT64, 0, "flex", 0, 8 }
};

struct C2TestStruct_FlexEndS64 {
    int32_t signed32;
    int64_t mSigned64Flex[];

    const static std::vector<C2FieldDescriptor> _FIELD_LIST;
    static const std::vector<C2FieldDescriptor> FieldList();
    // enum : uint32_t { CORE_INDEX = C2TestStruct_FlexEndS64, FLEX_SIZE = 8 };
    // typedef C2TestStruct_FlexEndS64 _type;
    // typedef int64_t FlexType;
};

const std::vector<C2FieldDescriptor> C2TestStruct_FlexEndS64::FieldList() {
    return _FIELD_LIST;
}
const std::vector<C2FieldDescriptor> C2TestStruct_FlexEndS64::_FIELD_LIST = {
    { FD::INT32, 1, "s32", 0, 4 },
    { FD::INT64, 0, "flex", 4, 8 },
};

struct C2TestFlexS64Struct {
    int64_t mFlexSigned64[];
    C2TestFlexS64Struct() {}

    DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(TestFlexS64, mFlexSigned64)
    C2FIELD(mFlexSigned64, "flex")
};

struct C2TestFlexEndS64Struct {
    int32_t signed32;
    int64_t mFlexSigned64[];
    C2TestFlexEndS64Struct() {}

    DEFINE_FLEX_C2STRUCT(TestFlexEndS64, mFlexSigned64)
} C2_PACK;

DESCRIBE_C2STRUCT(TestFlexEndS64, {
    C2FIELD(signed32, "s32")
    C2FIELD(mFlexSigned64, "flex")
}) // ; optional

template<>
std::vector<std::vector<C2FieldDescriptor>>
//std::vector<std::vector<C2FieldDescriptor>>
C2ParamTest_FlexParamFieldList<int64_t>::GetLists() {
    return {
        C2TestStruct_FlexS64::FieldList(),
        C2TestStruct_FlexEndS64::FieldList(),
        C2TestFlexS64Struct::FieldList(),
        C2TestFlexEndS64Struct::FieldList(),
    };
}

struct C2TestStruct_FlexSize {
    C2SizeStruct mFlexSize[];

    const static std::vector<C2FieldDescriptor> _FIELD_LIST;
    static const std::vector<C2FieldDescriptor> FieldList();
    // enum : uint32_t { CORE_INDEX = kParamIndexTestFlexSize, FLEX_SIZE = 8 };
    // typedef C2TestStruct_FlexSize _type;
    // typedef C2SizeStruct FlexType;
};

const std::vector<C2FieldDescriptor> C2TestStruct_FlexSize::FieldList() {
    return _FIELD_LIST;
}
const std::vector<C2FieldDescriptor> C2TestStruct_FlexSize::_FIELD_LIST = {
    { C2SizeStruct::TYPE, 0, "flex", 0, sizeof(C2SizeStruct) }
};

struct C2TestStruct_FlexEndSize {
    int32_t signed32;
    C2SizeStruct mSizeFlex[];

    const static std::vector<C2FieldDescriptor> _FIELD_LIST;
    static const std::vector<C2FieldDescriptor> FieldList();
    // enum : uint32_t { CORE_INDEX = C2TestStruct_FlexEndSize, FLEX_SIZE = 8 };
    // typedef C2TestStruct_FlexEndSize _type;
    // typedef C2SizeStruct FlexType;
};

const std::vector<C2FieldDescriptor> C2TestStruct_FlexEndSize::FieldList() {
    return _FIELD_LIST;
}
const std::vector<C2FieldDescriptor> C2TestStruct_FlexEndSize::_FIELD_LIST = {
    { FD::INT32, 1, "s32", 0, 4 },
    { C2SizeStruct::TYPE, 0, "flex", 4, sizeof(C2SizeStruct) },
};

struct C2TestFlexSizeStruct {
    C2SizeStruct mFlexSize[];
    C2TestFlexSizeStruct() {}

    DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(TestFlexSize, mFlexSize)
    C2FIELD(mFlexSize, "flex")
};

struct C2TestFlexEndSizeStruct {
    int32_t signed32;
    C2SizeStruct mFlexSize[];
    C2TestFlexEndSizeStruct() {}

    DEFINE_FLEX_C2STRUCT(TestFlexEndSize, mFlexSize)
} C2_PACK;

DESCRIBE_C2STRUCT(TestFlexEndSize, {
    C2FIELD(signed32, "s32")
    C2FIELD(mFlexSize, "flex")
}) // ; optional

struct C2TestBaseFlexEndSizeStruct {
    int32_t signed32;
    C2SizeStruct mFlexSize[];
    C2TestBaseFlexEndSizeStruct() {}

    DEFINE_BASE_FLEX_C2STRUCT(TestBaseFlexEndSize, mFlexSize)
} C2_PACK;

DESCRIBE_C2STRUCT(TestBaseFlexEndSize, {
    C2FIELD(signed32, "s32")
    C2FIELD(mFlexSize, "flex")
}) // ; optional

struct C2TestBaseFlexEndSize2Struct {
    int32_t signed32;
    C2SizeStruct mFlexSize[];
    C2TestBaseFlexEndSize2Struct() {}

    DEFINE_AND_DESCRIBE_BASE_FLEX_C2STRUCT(TestBaseFlexEndSize2, mFlexSize)
    C2FIELD(signed32, "s32")
    C2FIELD(mFlexSize, "flex")
};

template<>
std::vector<std::vector<C2FieldDescriptor>>
//std::vector<std::vector<C2FieldDescriptor>>
C2ParamTest_FlexParamFieldList<C2SizeStruct>::GetLists() {
    return {
        C2TestStruct_FlexSize::FieldList(),
        C2TestStruct_FlexEndSize::FieldList(),
        C2TestFlexSizeStruct::FieldList(),
        C2TestFlexEndSizeStruct::FieldList(),
        C2TestBaseFlexEndSizeStruct::FieldList(),
        C2TestBaseFlexEndSize2Struct::FieldList(),
    };
}

TEST_F(C2ParamTest, FieldId) {
    // pointer constructor
    EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId(&((C2TestStruct_A*)0)->signed32));
    EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId(&((C2TestStruct_A*)0)->signed64));
    EXPECT_EQ(_C2FieldId(20, 4), _C2FieldId(&((C2TestStruct_A*)0)->unsigned32));
    EXPECT_EQ(_C2FieldId(24, 8), _C2FieldId(&((C2TestStruct_A*)0)->unsigned64));
    EXPECT_EQ(_C2FieldId(32, 4), _C2FieldId(&((C2TestStruct_A*)0)->fp32));
    EXPECT_EQ(_C2FieldId(36, 8), _C2FieldId(&((C2TestStruct_A*)0)->sz));
    EXPECT_EQ(_C2FieldId(60, 1), _C2FieldId(&((C2TestStruct_A*)0)->blob));
    EXPECT_EQ(_C2FieldId(160, 1), _C2FieldId(&((C2TestStruct_A*)0)->string));
    EXPECT_EQ(_C2FieldId(260, 1), _C2FieldId(&((C2TestStruct_A*)0)->yesNo));

    EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId(&((C2TestFlexEndSizeStruct*)0)->signed32));
    EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId(&((C2TestFlexEndSizeStruct*)0)->mFlexSize));

    EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId(&((C2TestBaseFlexEndSizeStruct*)0)->signed32));
    EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId(&((C2TestBaseFlexEndSizeStruct*)0)->mFlexSize));

    // member pointer constructor
    EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::signed32));
    EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::signed64));
    EXPECT_EQ(_C2FieldId(20, 4), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::unsigned32));
    EXPECT_EQ(_C2FieldId(24, 8), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::unsigned64));
    EXPECT_EQ(_C2FieldId(32, 4), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::fp32));
    EXPECT_EQ(_C2FieldId(36, 8), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::sz));
    EXPECT_EQ(_C2FieldId(60, 1), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::blob));
    EXPECT_EQ(_C2FieldId(160, 1), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::string));
    EXPECT_EQ(_C2FieldId(260, 1), _C2FieldId((C2TestStruct_A*)0, &C2TestStruct_A::yesNo));

    EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId((C2TestFlexEndSizeStruct*)0, &C2TestFlexEndSizeStruct::signed32));
    EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId((C2TestFlexEndSizeStruct*)0, &C2TestFlexEndSizeStruct::mFlexSize));

    EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId((C2TestBaseFlexEndSizeStruct*)0, &C2TestBaseFlexEndSizeStruct::signed32));
    EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId((C2TestBaseFlexEndSizeStruct*)0, &C2TestBaseFlexEndSizeStruct::mFlexSize));

    // member pointer sans type pointer
    EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId(&C2TestStruct_A::signed32));
    EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId(&C2TestStruct_A::signed64));
    EXPECT_EQ(_C2FieldId(20, 4), _C2FieldId(&C2TestStruct_A::unsigned32));
    EXPECT_EQ(_C2FieldId(24, 8), _C2FieldId(&C2TestStruct_A::unsigned64));
    EXPECT_EQ(_C2FieldId(32, 4), _C2FieldId(&C2TestStruct_A::fp32));
    EXPECT_EQ(_C2FieldId(36, 8), _C2FieldId(&C2TestStruct_A::sz));
    EXPECT_EQ(_C2FieldId(60, 1), _C2FieldId(&C2TestStruct_A::blob));
    EXPECT_EQ(_C2FieldId(160, 1), _C2FieldId(&C2TestStruct_A::string));
    EXPECT_EQ(_C2FieldId(260, 1), _C2FieldId(&C2TestStruct_A::yesNo));

    EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId(&C2TestFlexEndSizeStruct::signed32));
    EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId(&C2TestFlexEndSizeStruct::mFlexSize));

    EXPECT_EQ(_C2FieldId(0, 4), _C2FieldId(&C2TestBaseFlexEndSizeStruct::signed32));
    EXPECT_EQ(_C2FieldId(4, 8), _C2FieldId(&C2TestBaseFlexEndSizeStruct::mFlexSize));

    typedef C2GlobalParam<C2Info, C2TestAStruct> C2TestAInfo;
    typedef C2GlobalParam<C2Info, C2TestFlexEndSizeStruct> C2TestFlexEndSizeInfo;
    typedef C2GlobalParam<C2Info, C2TestBaseFlexEndSizeStruct, kParamIndexTestFlexEndSize> C2TestFlexEndSizeInfoFromBase;

    // pointer constructor in C2Param
    EXPECT_EQ(_C2FieldId(8, 4), _C2FieldId(&((C2TestAInfo*)0)->signed32));
    EXPECT_EQ(_C2FieldId(12, 8), _C2FieldId(&((C2TestAInfo*)0)->signed64));
    EXPECT_EQ(_C2FieldId(28, 4), _C2FieldId(&((C2TestAInfo*)0)->unsigned32));
    EXPECT_EQ(_C2FieldId(32, 8), _C2FieldId(&((C2TestAInfo*)0)->unsigned64));
    EXPECT_EQ(_C2FieldId(40, 4), _C2FieldId(&((C2TestAInfo*)0)->fp32));
    EXPECT_EQ(_C2FieldId(44, 8), _C2FieldId(&((C2TestAInfo*)0)->sz));
    EXPECT_EQ(_C2FieldId(68, 1), _C2FieldId(&((C2TestAInfo*)0)->blob));
    EXPECT_EQ(_C2FieldId(168, 1), _C2FieldId(&((C2TestAInfo*)0)->string));
    EXPECT_EQ(_C2FieldId(268, 1), _C2FieldId(&((C2TestAInfo*)0)->yesNo));

    EXPECT_EQ(_C2FieldId(8, 4), _C2FieldId(&((C2TestFlexEndSizeInfo*)0)->m.signed32));
    EXPECT_EQ(_C2FieldId(12, 8), _C2FieldId(&((C2TestFlexEndSizeInfo*)0)->m.mFlexSize));

    EXPECT_EQ(_C2FieldId(8, 4), _C2FieldId(&((C2TestFlexEndSizeInfoFromBase*)0)->m.signed32));
    EXPECT_EQ(_C2FieldId(12, 8), _C2FieldId(&((C2TestFlexEndSizeInfoFromBase*)0)->m.mFlexSize));

    // member pointer in C2Param
    EXPECT_EQ(_C2FieldId(8, 4), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::signed32));
    EXPECT_EQ(_C2FieldId(12, 8), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::signed64));
    EXPECT_EQ(_C2FieldId(28, 4), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::unsigned32));
    EXPECT_EQ(_C2FieldId(32, 8), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::unsigned64));
    EXPECT_EQ(_C2FieldId(40, 4), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::fp32));
    EXPECT_EQ(_C2FieldId(44, 8), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::sz));
    EXPECT_EQ(_C2FieldId(68, 1), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::blob));
    EXPECT_EQ(_C2FieldId(168, 1), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::string));
    EXPECT_EQ(_C2FieldId(268, 1), _C2FieldId((C2TestAInfo*)0, &C2TestAInfo::yesNo));

    // NOTE: cannot use a member pointer for flex params due to introduction of 'm'
    // EXPECT_EQ(_C2FieldId(8, 4), _C2FieldId(&C2TestFlexEndSizeInfo::m.signed32));
    // EXPECT_EQ(_C2FieldId(12, 8), _C2FieldId(&C2TestFlexEndSizeInfo::m.mFlexSize));

    // EXPECT_EQ(_C2FieldId(8, 4), _C2FieldId(&C2TestFlexEndSizeInfoFromBase::m.signed32));
    // EXPECT_EQ(_C2FieldId(12, 8), _C2FieldId(&C2TestFlexEndSizeInfoFromBase::m.mFlexSize));


}

struct S32 {
    template<typename T, class B=typename std::remove_extent<T>::type>
    inline S32(const T*) {
        static_assert(!std::is_array<T>::value, "should not be an array");
        static_assert(std::is_same<B, int32_t>::value, "should be int32_t");
    }
};

struct FLX {
    template<typename U, typename T, class B=typename std::remove_extent<T>::type>
    inline FLX(const T*, const U*) {
        static_assert(std::is_array<T>::value, "should be an array");
        static_assert(std::extent<T>::value == 0, "should be an array of 0 extent");
        static_assert(std::is_same<B, U>::value, "should be type U");
    }
};

struct MP {
    template<typename U, typename T, typename ExpectedU, typename UnexpectedU>
    inline MP(T U::*, const ExpectedU*, const UnexpectedU*) {
        static_assert(!std::is_same<U, UnexpectedU>::value, "should not be member pointer of the base type");
        static_assert(std::is_same<U, ExpectedU>::value, "should be member pointer of the derived type");
    }

    template<typename U, typename T, typename B, typename D>
    inline MP(T D::*, const D*) { }
};

void compiledStatic_arrayTypePropagationTest() {
    (void)S32(&((C2TestFlexEndS32Struct *)0)->signed32);
    (void)FLX(&((C2TestFlexEndS32Struct *)0)->mFlexSigned32, (int32_t*)0);
    (void)FLX(&((C2TestFlexS32Struct *)0)->mFlexSigned32, (int32_t*)0);

    typedef C2GlobalParam<C2Info, C2TestAStruct> C2TestAInfo;

    // TRICKY: &derivedClass::baseMember has type of baseClass::*
    static_assert(std::is_same<decltype(&C2TestAInfo::signed32), int32_t C2TestAStruct::*>::value,
                  "base member pointer should have base class in type");

    // therefore, member pointer expands to baseClass::* in templates
    (void)MP(&C2TestAInfo::signed32,
             (C2TestAStruct*)0 /* expected */, (C2TestAInfo*)0 /* unexpected */);
    // but can be cast to derivedClass::*
    (void)MP((int32_t C2TestAInfo::*)&C2TestAInfo::signed32,
             (C2TestAInfo*)0 /* expected */, (C2TestAStruct*)0 /* unexpected */);

    // TRICKY: baseClass::* does not autoconvert to derivedClass::* even in templates
    // (void)MP(&C2TestAInfo::signed32, (C2TestAInfo*)0);
}

TEST_F(C2ParamTest, MemberPointerCast) {
    typedef C2GlobalParam<C2Info, C2TestAStruct> C2TestAInfo;

    static_assert(offsetof(C2TestAInfo, signed32) == 8, "offset should be 8");
    constexpr int32_t C2TestAStruct::* s32ptr = &C2TestAInfo::signed32;
    constexpr int32_t C2TestAInfo::* s32ptr_derived = (int32_t C2TestAStruct::*)&C2TestAInfo::signed32;
    constexpr int32_t C2TestAInfo::* s32ptr_cast2derived = (int32_t C2TestAInfo::*)s32ptr;
    C2TestAInfo *info = (C2TestAInfo *)256;
    C2TestAStruct *strukt = (C2TestAStruct *)info;
    int32_t *info_s32_derived = &(info->*s32ptr_derived);
    int32_t *info_s32_cast2derived = &(info->*s32ptr_cast2derived);
    int32_t *info_s32 = &(info->*s32ptr);
    int32_t *strukt_s32 = &(strukt->*s32ptr);

    EXPECT_EQ(256u, (uintptr_t)info);
    EXPECT_EQ(264u, (uintptr_t)strukt);
    EXPECT_EQ(264u, (uintptr_t)info_s32_derived);
    EXPECT_EQ(264u, (uintptr_t)info_s32_cast2derived);
    EXPECT_EQ(264u, (uintptr_t)info_s32);
    EXPECT_EQ(264u, (uintptr_t)strukt_s32);

    typedef C2GlobalParam<C2Info, C2TestFlexEndSizeStruct> C2TestFlexEndSizeInfo;
    static_assert(offsetof(C2TestFlexEndSizeInfo, m.signed32) == 8, "offset should be 8");
    static_assert(offsetof(C2TestFlexEndSizeInfo, m.mFlexSize) == 12, "offset should be 12");

    typedef C2GlobalParam<C2Info, C2TestBaseFlexEndSizeStruct, kParamIndexTestFlexEndSize> C2TestFlexEndSizeInfoFromBase;
    static_assert(offsetof(C2TestFlexEndSizeInfoFromBase, m.signed32) == 8, "offset should be 8");
    static_assert(offsetof(C2TestFlexEndSizeInfoFromBase, m.mFlexSize) == 12, "offset should be 12");
}

/* ===================================== PARAM USAGE TESTS ===================================== */

struct C2NumberStruct {
    int32_t mNumber;
    C2NumberStruct() {}
    C2NumberStruct(int32_t _number) : mNumber(_number) {}

    DEFINE_AND_DESCRIBE_C2STRUCT(Number)
    C2FIELD(mNumber, "number")
};

struct C2NumberBaseStruct {
    int32_t mNumber;
    C2NumberBaseStruct() {}
    C2NumberBaseStruct(int32_t _number) : mNumber(_number) {}

    DEFINE_AND_DESCRIBE_BASE_C2STRUCT(NumberBase)
    C2FIELD(mNumber, "number")
};

struct C2NumbersStruct {
    int32_t mNumbers[];
    C2NumbersStruct() {}

    DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(Numbers, mNumbers)
    C2FIELD(mNumbers, "numbers")
};
static_assert(sizeof(C2NumbersStruct) == 0, "C2NumbersStruct has incorrect size");

typedef C2GlobalParam<C2Info, C2NumberStruct> C2NumberInfo;

typedef C2GlobalParam<C2Tuning, C2NumberStruct> C2NumberTuning;
typedef   C2PortParam<C2Tuning, C2NumberStruct> C2NumberPortTuning;
typedef C2StreamParam<C2Tuning, C2NumberStruct> C2NumberStreamTuning;

typedef C2GlobalParam<C2Tuning, C2NumbersStruct> C2NumbersTuning;
typedef   C2PortParam<C2Tuning, C2NumbersStruct> C2NumbersPortTuning;
typedef C2StreamParam<C2Tuning, C2NumbersStruct> C2NumbersStreamTuning;

//
#if 0

void test() {
    C2NumberStruct s(10);
    (void)C2NumberStruct::FieldList();
};

typedef C2StreamParam<C2Tuning, C2Int64Value, kParamIndexNumberB> C2NumberConfig4;
typedef C2PortParam<C2Tuning, C2Int32Value, kParamIndexNumber> C2NumberConfig3;
typedef C2GlobalParam<C2Tuning, C2StringValue, kParamIndexNumber> C2VideoNameConfig;

void test3() {
    C2NumberConfig3 s(10);
    s.value = 11;
    s = 12;
    (void)C2NumberConfig3::FieldList();
    std::shared_ptr<C2VideoNameConfig> n = C2VideoNameConfig::AllocShared(25);
    strcpy(n->m.value, "lajos");
    C2NumberConfig4 t(false, 0, 11);
    t.value = 15;
};

struct C2NumbersStruct {
    int32_t mNumbers[];
    enum { CORE_INDEX = kParamIndexNumber };
    const static std::vector<C2FieldDescriptor> FieldList();
    static const std::vector<C2FieldDescriptor> FieldList();
    C2NumbersStruct() {}

    FLEX(C2NumbersStruct, mNumbers);
};

static_assert(sizeof(C2NumbersStruct) == 0, "yes");


typedef C2GlobalParam<C2Info, C2NumbersStruct> C2NumbersInfo;

const std::vector<C2FieldDescriptor> C2NumbersStruct::FieldList() {
    return _FIELD_LIST;
}
const std::vector<C2FieldDescriptor> C2NumbersStruct::_FIELD_LIST =
//    { { FD::INT32, 0, "widths" } };
    { C2FieldDescriptor(&((C2NumbersStruct*)(nullptr))->mNumbers, "number") };

typedef C2PortParam<C2Tuning, C2NumberStruct> C2NumberConfig;

std::vector<C2FieldDescriptor> myList = C2NumberConfig::FieldList();

    std::unique_ptr<C2ParamDescriptor> __test_describe(uint32_t paramType) {
        std::list<C2FieldDescriptor> fields = describeC2Params<C2NumberConfig>();

        auto widths = C2NumbersInfo::AllocShared(5);
        widths->flexCount();
        widths->m.mNumbers[4] = 1;

        test();
        test3();

        C2NumberConfig outputWidth(false, 123);

        C2Param::Index index(paramType);
        switch (paramType) {
        case C2NumberConfig::CORE_INDEX:
            return std::unique_ptr<C2ParamDescriptor>(new C2ParamDescriptor{
                true /* isRequired */,
                "number",
                index,
            });
        }
        return nullptr;
    }


} // namespace android

#endif
//

template<typename T>
bool canSetPort(T &o, bool output) { return o.setPort(output); }
bool canSetPort(...) { return false; }

template<typename S, typename=decltype(((S*)0)->setPort(true))>
static std::true_type _canCallSetPort(int);
template<typename>
static std::false_type _canCallSetPort(...);
#define canCallSetPort(x) decltype(_canCallSetPort<std::remove_reference<decltype(x)>::type>(0))::value

/* ======================================= STATIC TESTS ======================================= */

static_assert(_C2Comparable<int>::value, "int is not comparable");
static_assert(!_C2Comparable<void>::value, "void is comparable");

struct C2_HIDE _test0 {
    bool operator==(const _test0&);
    bool operator!=(const _test0&);
};
struct C2_HIDE _test1 {
    bool operator==(const _test1&);
};
struct C2_HIDE _test2 {
    bool operator!=(const _test2&);
};
static_assert(_C2Comparable<_test0>::value, "class with == and != is not comparable");
static_assert(_C2Comparable<_test1>::value, "class with == is not comparable");
static_assert(_C2Comparable<_test2>::value, "class with != is not comparable");

/* ======================================= C2PARAM TESTS ======================================= */

struct _C2ParamInspector {
    static void StaticTest();
    static void StaticFromBaseTest();
    static void StaticFlexTest();
    static void StaticFlexFromBaseTest();
};

// TEST_F(_C2ParamInspector, StaticTest) {
void _C2ParamInspector::StaticTest() {
    typedef C2Param::Index I;

    // C2NumberStruct: CORE_INDEX = kIndex                          (args)
    static_assert(C2NumberStruct::CORE_INDEX == kParamIndexNumber, "bad index");
    static_assert(sizeof(C2NumberStruct) == 4, "bad size");

    // C2NumberTuning:             kIndex | tun | global           (args)
    static_assert(C2NumberTuning::CORE_INDEX == kParamIndexNumber, "bad index");
    static_assert(C2NumberTuning::PARAM_TYPE == (kParamIndexNumber | I::KIND_TUNING | I::DIR_GLOBAL), "bad index");
    static_assert(sizeof(C2NumberTuning) == 12, "bad size");

    static_assert(offsetof(C2NumberTuning, _mSize) == 0, "bad size");
    static_assert(offsetof(C2NumberTuning, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2NumberTuning, mNumber) == 8, "bad offset");

    // C2NumberPortTuning:         kIndex | tun | port             (bool, args)
    static_assert(sizeof(C2NumberPortTuning) == 12, "bad size");
    // C2NumberPortTuning::input:  kIndex | tun | port | input     (args)
    // C2NumberPortTuning::output: kIndex | tun | port | output    (args)
    static_assert(C2NumberPortTuning::input::CORE_INDEX ==
                  kParamIndexNumber, "bad index");
    static_assert(C2NumberPortTuning::input::PARAM_TYPE ==
                  (kParamIndexNumber | I::KIND_TUNING | I::DIR_INPUT), "bad index");
    static_assert(C2NumberPortTuning::output::CORE_INDEX ==
                  kParamIndexNumber, "bad index");
    static_assert(C2NumberPortTuning::output::PARAM_TYPE ==
                  (kParamIndexNumber | I::KIND_TUNING | I::DIR_OUTPUT), "bad index");
    static_assert(sizeof(C2NumberPortTuning::input) == 12, "bad size");
    static_assert(sizeof(C2NumberPortTuning::output) == 12, "bad size");
    static_assert(offsetof(C2NumberPortTuning::input, _mSize) == 0, "bad size");
    static_assert(offsetof(C2NumberPortTuning::input, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2NumberPortTuning::input, mNumber) == 8, "bad offset");
    static_assert(offsetof(C2NumberPortTuning::output, _mSize) == 0, "bad size");
    static_assert(offsetof(C2NumberPortTuning::output, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2NumberPortTuning::output, mNumber) == 8, "bad offset");

    // C2NumberStreamTuning:       kIndex | tun | str              (bool, uint, args)
    static_assert(sizeof(C2NumberStreamTuning) == 12u, "bad size");
    // C2NumberStreamTuning::input kIndex | tun | str | input      (int, args)
    // C2NumberStreamTuning::output kIx   | tun | str | output     (int, args)
    static_assert(C2NumberStreamTuning::input::CORE_INDEX ==
                  kParamIndexNumber, "bad index");
    static_assert(C2NumberStreamTuning::input::PARAM_TYPE ==
                  (kParamIndexNumber | I::KIND_TUNING | I::DIR_INPUT | I::IS_STREAM_FLAG), "bad index");
    static_assert(C2NumberStreamTuning::output::CORE_INDEX ==
                  kParamIndexNumber, "bad index");
    static_assert(C2NumberStreamTuning::output::PARAM_TYPE ==
                  (kParamIndexNumber | I::KIND_TUNING | I::DIR_OUTPUT | I::IS_STREAM_FLAG), "bad index");
    static_assert(sizeof(C2NumberStreamTuning::input) == 12u, "bad size");
    static_assert(sizeof(C2NumberStreamTuning::output) == 12u, "bad size");
    static_assert(offsetof(C2NumberStreamTuning::input, _mSize) == 0, "bad size");
    static_assert(offsetof(C2NumberStreamTuning::input, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2NumberStreamTuning::input, mNumber) == 8, "bad offset");
    static_assert(offsetof(C2NumberStreamTuning::output, _mSize) == 0, "bad size");
    static_assert(offsetof(C2NumberStreamTuning::output, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2NumberStreamTuning::output, mNumber) == 8, "bad offset");
}

void _C2ParamInspector::StaticFromBaseTest() {
    enum { kParamIndexMy = 3102 };
    typedef C2NumberBaseStruct C2MyStruct;
    typedef C2GlobalParam<C2Setting, C2MyStruct, kParamIndexMy> C2MySetting;
    typedef   C2PortParam<C2Setting, C2MyStruct, kParamIndexMy> C2MyPortSetting;
    typedef C2StreamParam<C2Setting, C2MyStruct, kParamIndexMy> C2MyStreamSetting;

    typedef C2Param::Index I;

    // C2MyStruct has no CORE_INDEX
    //static_assert(C2MyStruct::CORE_INDEX == kParamIndexMy, "bad index");
    static_assert(sizeof(C2MyStruct) == 4, "bad size");

    // C2MySetting:             kIndex | tun | global           (args)
    static_assert(C2MySetting::CORE_INDEX == kParamIndexMy, "bad index");
    static_assert(C2MySetting::PARAM_TYPE == (kParamIndexMy | I::KIND_SETTING | I::DIR_GLOBAL), "bad index");
    static_assert(sizeof(C2MySetting) == 12, "bad size");

    static_assert(offsetof(C2MySetting, _mSize) == 0, "bad size");
    static_assert(offsetof(C2MySetting, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2MySetting, mNumber) == 8, "bad offset");

    // C2MyPortSetting:         kIndex | tun | port             (bool, args)
    static_assert(sizeof(C2MyPortSetting) == 12, "bad size");
    // C2MyPortSetting::input:  kIndex | tun | port | input     (args)
    // C2MyPortSetting::output: kIndex | tun | port | output    (args)
    static_assert(C2MyPortSetting::input::CORE_INDEX ==
                  kParamIndexMy, "bad index");
    static_assert(C2MyPortSetting::input::PARAM_TYPE ==
                  (kParamIndexMy | I::KIND_SETTING | I::DIR_INPUT), "bad index");
    static_assert(C2MyPortSetting::output::CORE_INDEX ==
                  kParamIndexMy, "bad index");
    static_assert(C2MyPortSetting::output::PARAM_TYPE ==
                  (kParamIndexMy | I::KIND_SETTING | I::DIR_OUTPUT), "bad index");
    static_assert(sizeof(C2MyPortSetting::input) == 12, "bad size");
    static_assert(sizeof(C2MyPortSetting::output) == 12, "bad size");
    static_assert(offsetof(C2MyPortSetting::input, _mSize) == 0, "bad size");
    static_assert(offsetof(C2MyPortSetting::input, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2MyPortSetting::input, mNumber) == 8, "bad offset");
    static_assert(offsetof(C2MyPortSetting::output, _mSize) == 0, "bad size");
    static_assert(offsetof(C2MyPortSetting::output, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2MyPortSetting::output, mNumber) == 8, "bad offset");

    // C2MyStreamSetting:       kIndex | tun | str              (bool, uint, args)
    static_assert(sizeof(C2MyStreamSetting) == 12u, "bad size");
    // C2MyStreamSetting::input kIndex | tun | str | input      (int, args)
    // C2MyStreamSetting::output kIx   | tun | str | output     (int, args)
    static_assert(C2MyStreamSetting::input::CORE_INDEX ==
                  kParamIndexMy, "bad index");
    static_assert(C2MyStreamSetting::input::PARAM_TYPE ==
                  (kParamIndexMy | I::KIND_SETTING | I::DIR_INPUT | I::IS_STREAM_FLAG), "bad index");
    static_assert(C2MyStreamSetting::output::CORE_INDEX ==
                  kParamIndexMy, "bad index");
    static_assert(C2MyStreamSetting::output::PARAM_TYPE ==
                  (kParamIndexMy | I::KIND_SETTING | I::DIR_OUTPUT | I::IS_STREAM_FLAG), "bad index");
    static_assert(sizeof(C2MyStreamSetting::input) == 12u, "bad size");
    static_assert(sizeof(C2MyStreamSetting::output) == 12u, "bad size");
    static_assert(offsetof(C2MyStreamSetting::input, _mSize) == 0, "bad size");
    static_assert(offsetof(C2MyStreamSetting::input, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2MyStreamSetting::input, mNumber) == 8, "bad offset");
    static_assert(offsetof(C2MyStreamSetting::output, _mSize) == 0, "bad size");
    static_assert(offsetof(C2MyStreamSetting::output, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2MyStreamSetting::output, mNumber) == 8, "bad offset");
}

void _C2ParamInspector::StaticFlexTest() {
    typedef C2Param::Index I;

    // C2NumbersStruct: CORE_INDEX = kIndex                          (args)
    static_assert(C2NumbersStruct::CORE_INDEX == (I::IS_FLEX_FLAG | kParamIndexNumbers), "bad index");
    static_assert(sizeof(C2NumbersStruct) == 0, "bad size");

    // C2NumbersTuning:             kIndex | tun | global           (args)
    static_assert(C2NumbersTuning::CORE_INDEX == (I::IS_FLEX_FLAG | kParamIndexNumbers), "bad index");
    static_assert(C2NumbersTuning::PARAM_TYPE == (I::IS_FLEX_FLAG | kParamIndexNumbers | I::KIND_TUNING | I::DIR_GLOBAL), "bad index");
    static_assert(sizeof(C2NumbersTuning) == 8, "bad size");

    static_assert(offsetof(C2NumbersTuning, _mSize) == 0, "bad size");
    static_assert(offsetof(C2NumbersTuning, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2NumbersTuning, m.mNumbers) == 8, "bad offset");

    // C2NumbersPortTuning:         kIndex | tun | port             (bool, args)
    static_assert(sizeof(C2NumbersPortTuning) == 8, "bad size");
    // C2NumbersPortTuning::input:  kIndex | tun | port | input     (args)
    // C2NumbersPortTuning::output: kIndex | tun | port | output    (args)
    static_assert(C2NumbersPortTuning::input::CORE_INDEX ==
                  (I::IS_FLEX_FLAG | kParamIndexNumbers), "bad index");
    static_assert(C2NumbersPortTuning::input::PARAM_TYPE ==
                  (I::IS_FLEX_FLAG | kParamIndexNumbers | I::KIND_TUNING | I::DIR_INPUT), "bad index");
    static_assert(C2NumbersPortTuning::output::CORE_INDEX ==
                  (I::IS_FLEX_FLAG | kParamIndexNumbers), "bad index");
    static_assert(C2NumbersPortTuning::output::PARAM_TYPE ==
                  (I::IS_FLEX_FLAG | kParamIndexNumbers | I::KIND_TUNING | I::DIR_OUTPUT), "bad index");
    static_assert(sizeof(C2NumbersPortTuning::input) == 8, "bad size");
    static_assert(sizeof(C2NumbersPortTuning::output) == 8, "bad size");
    static_assert(offsetof(C2NumbersPortTuning::input, _mSize) == 0, "bad size");
    static_assert(offsetof(C2NumbersPortTuning::input, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2NumbersPortTuning::input, m.mNumbers) == 8, "bad offset");
    static_assert(offsetof(C2NumbersPortTuning::output, _mSize) == 0, "bad size");
    static_assert(offsetof(C2NumbersPortTuning::output, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2NumbersPortTuning::output, m.mNumbers) == 8, "bad offset");

    // C2NumbersStreamTuning:       kIndex | tun | str              (bool, uint, args)
    static_assert(sizeof(C2NumbersStreamTuning) == 8, "bad size");
    // C2NumbersStreamTuning::input kIndex | tun | str | input      (int, args)
    // C2NumbersStreamTuning::output kIx   | tun | str | output     (int, args)
    static_assert(C2NumbersStreamTuning::input::CORE_INDEX ==
                  (I::IS_FLEX_FLAG | kParamIndexNumbers), "bad index");
    static_assert(C2NumbersStreamTuning::input::PARAM_TYPE ==
                  (I::IS_FLEX_FLAG | kParamIndexNumbers | I::KIND_TUNING | I::DIR_INPUT | I::IS_STREAM_FLAG), "bad index");
    static_assert(C2NumbersStreamTuning::output::CORE_INDEX ==
                  (I::IS_FLEX_FLAG | kParamIndexNumbers), "bad index");
    static_assert(C2NumbersStreamTuning::output::PARAM_TYPE ==
                  (I::IS_FLEX_FLAG | kParamIndexNumbers | I::KIND_TUNING | I::DIR_OUTPUT | I::IS_STREAM_FLAG), "bad index");
    static_assert(sizeof(C2NumbersStreamTuning::input) == 8, "bad size");
    static_assert(sizeof(C2NumbersStreamTuning::output) == 8, "bad size");
    static_assert(offsetof(C2NumbersStreamTuning::input, _mSize) == 0, "bad size");
    static_assert(offsetof(C2NumbersStreamTuning::input, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2NumbersStreamTuning::input, m.mNumbers) == 8, "bad offset");
    static_assert(offsetof(C2NumbersStreamTuning::output, _mSize) == 0, "bad size");
    static_assert(offsetof(C2NumbersStreamTuning::output, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2NumbersStreamTuning::output, m.mNumbers) == 8, "bad offset");
}

template<bool, unsigned ...N>
struct _print_as_warning { };

template<unsigned ...N>
struct _print_as_warning<true, N...> : std::true_type { };

#define static_assert_equals(a, b, msg) \
static_assert(_print_as_warning<(a) == (b), a, b>::value, msg)

void _C2ParamInspector::StaticFlexFromBaseTest() {
    enum { kParamIndexMy = 1203 };
    typedef C2TestBaseFlexEndSizeStruct C2MyStruct;
    typedef C2GlobalParam<C2Info, C2MyStruct, kParamIndexMy> C2MyInfo;
    typedef   C2PortParam<C2Info, C2MyStruct, kParamIndexMy> C2MyPortInfo;
    typedef C2StreamParam<C2Info, C2MyStruct, kParamIndexMy> C2MyStreamInfo;

    typedef C2Param::Index I;

    // C2MyStruct has no CORE_INDEX
    //static_assert(C2MyStruct::CORE_INDEX == (I::IS_FLEX_FLAG | kParamIndexMy), "bad index");
    static_assert(sizeof(C2MyStruct) == 4, "bad size");

    // C2MyInfo:             kIndex | tun | global           (args)
    static_assert_equals(C2MyInfo::CORE_INDEX, (I::IS_FLEX_FLAG | kParamIndexMy), "bad index");
    static_assert_equals(C2MyInfo::PARAM_TYPE, (I::IS_FLEX_FLAG | kParamIndexMy | I::KIND_INFO | I::DIR_GLOBAL), "bad index");
    static_assert(sizeof(C2MyInfo) == 12, "bad size");

    static_assert(offsetof(C2MyInfo, _mSize) == 0, "bad size");
    static_assert(offsetof(C2MyInfo, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2MyInfo, m.signed32) == 8, "bad offset");

    // C2MyPortInfo:         kIndex | tun | port             (bool, args)
    static_assert(sizeof(C2MyPortInfo) == 12, "bad size");
    // C2MyPortInfo::input:  kIndex | tun | port | input     (args)
    // C2MyPortInfo::output: kIndex | tun | port | output    (args)
    static_assert(C2MyPortInfo::input::CORE_INDEX ==
                  (I::IS_FLEX_FLAG | kParamIndexMy), "bad index");
    static_assert(C2MyPortInfo::input::PARAM_TYPE ==
                  (I::IS_FLEX_FLAG | kParamIndexMy | I::KIND_INFO | I::DIR_INPUT), "bad index");
    static_assert(C2MyPortInfo::output::CORE_INDEX ==
                  (I::IS_FLEX_FLAG | kParamIndexMy), "bad index");
    static_assert(C2MyPortInfo::output::PARAM_TYPE ==
                  (I::IS_FLEX_FLAG | kParamIndexMy | I::KIND_INFO | I::DIR_OUTPUT), "bad index");
    static_assert(sizeof(C2MyPortInfo::input) == 12, "bad size");
    static_assert(sizeof(C2MyPortInfo::output) == 12, "bad size");
    static_assert(offsetof(C2MyPortInfo::input, _mSize) == 0, "bad size");
    static_assert(offsetof(C2MyPortInfo::input, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2MyPortInfo::input, m.signed32) == 8, "bad offset");
    static_assert(offsetof(C2MyPortInfo::output, _mSize) == 0, "bad size");
    static_assert(offsetof(C2MyPortInfo::output, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2MyPortInfo::output, m.signed32) == 8, "bad offset");

    // C2MyStreamInfo:       kIndex | tun | str              (bool, uint, args)
    static_assert(sizeof(C2MyStreamInfo) == 12, "bad size");
    // C2MyStreamInfo::input kIndex | tun | str | input      (int, args)
    // C2MyStreamInfo::output kIx   | tun | str | output     (int, args)
    static_assert(C2MyStreamInfo::input::CORE_INDEX ==
                  (I::IS_FLEX_FLAG | kParamIndexMy), "bad index");
    static_assert(C2MyStreamInfo::input::PARAM_TYPE ==
                  (I::IS_FLEX_FLAG | kParamIndexMy | I::KIND_INFO | I::DIR_INPUT | I::IS_STREAM_FLAG), "bad index");
    static_assert(C2MyStreamInfo::output::CORE_INDEX ==
                  (I::IS_FLEX_FLAG | kParamIndexMy), "bad index");
    static_assert(C2MyStreamInfo::output::PARAM_TYPE ==
                  (I::IS_FLEX_FLAG | kParamIndexMy | I::KIND_INFO | I::DIR_OUTPUT | I::IS_STREAM_FLAG), "bad index");
    static_assert(sizeof(C2MyStreamInfo::input) == 12, "bad size");
    static_assert(sizeof(C2MyStreamInfo::output) == 12, "bad size");
    static_assert(offsetof(C2MyStreamInfo::input, _mSize) == 0, "bad size");
    static_assert(offsetof(C2MyStreamInfo::input, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2MyStreamInfo::input, m.signed32) == 8, "bad offset");
    static_assert(offsetof(C2MyStreamInfo::output, _mSize) == 0, "bad size");
    static_assert(offsetof(C2MyStreamInfo::output, _mIndex) == 4, "bad offset");
    static_assert(offsetof(C2MyStreamInfo::output, m.signed32) == 8, "bad offset");
}

TEST_F(C2ParamTest, ParamOpsTest) {
    const C2NumberStruct str(100);
    C2NumberStruct bstr;

    {
        EXPECT_EQ(100, str.mNumber);
        bstr.mNumber = 100;

        C2Param::CoreIndex index = C2NumberStruct::CORE_INDEX;
        EXPECT_FALSE(index.isVendor());
        EXPECT_FALSE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumber);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumber);
    }

    const C2NumberTuning tun(100);
    C2NumberTuning btun;

    {
      C2NumberInfo inf(100);
      std::unique_ptr<C2NumbersTuning> tun_ = C2NumbersTuning::AllocUnique(1);

      EXPECT_EQ(tun.coreIndex(), inf.coreIndex());
      EXPECT_NE(tun.coreIndex(), tun_->coreIndex());
      EXPECT_NE(tun.type(), inf.type());
      EXPECT_NE(tun.type(), tun_->type());
    }

    {
        // flags & invariables
        for (const auto &p : { tun, btun }) {
            EXPECT_TRUE((bool)p);
            EXPECT_FALSE(!p);
            EXPECT_EQ(12u, p.size());

            EXPECT_FALSE(p.isVendor());
            EXPECT_FALSE(p.isFlexible());
            EXPECT_TRUE(p.isGlobal());
            EXPECT_FALSE(p.forInput());
            EXPECT_FALSE(p.forOutput());
            EXPECT_FALSE(p.forStream());
            EXPECT_FALSE(p.forPort());
        }

        // value
        EXPECT_EQ(100, tun.mNumber);
        EXPECT_EQ(0, btun.mNumber);
        EXPECT_FALSE(tun == btun);
        EXPECT_FALSE(tun.operator==(btun));
        EXPECT_TRUE(tun != btun);
        EXPECT_TRUE(tun.operator!=(btun));
        btun.mNumber = 100;
        EXPECT_EQ(tun, btun);

        // index
        EXPECT_EQ(C2Param::Type(tun.type()).coreIndex(), C2NumberStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(tun.type()).typeIndex(), kParamIndexNumber);
        EXPECT_EQ(tun.type(), C2NumberTuning::PARAM_TYPE);
        EXPECT_EQ(tun.stream(), ~0u);

        C2Param::CoreIndex index = C2NumberTuning::CORE_INDEX;
        EXPECT_FALSE(index.isVendor());
        EXPECT_FALSE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumber);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumber);

        C2Param::Type type = C2NumberTuning::PARAM_TYPE;
        EXPECT_FALSE(type.isVendor());
        EXPECT_FALSE(type.isFlexible());
        EXPECT_TRUE(type.isGlobal());
        EXPECT_FALSE(type.forInput());
        EXPECT_FALSE(type.forOutput());
        EXPECT_FALSE(type.forStream());
        EXPECT_FALSE(type.forPort());

        EXPECT_EQ(C2NumberTuning::From(nullptr), nullptr);
        EXPECT_EQ(C2NumberTuning::From(&tun), &tun);
        EXPECT_EQ(C2NumberPortTuning::From(&tun), nullptr);
        EXPECT_EQ(C2NumberPortTuning::input::From(&tun), nullptr);
        EXPECT_EQ(C2NumberPortTuning::output::From(&tun), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::From(&tun), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::input::From(&tun), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::output::From(&tun), nullptr);

        EXPECT_EQ(*(C2Param::Copy(btun)), btun);
        btun.invalidate();
        EXPECT_FALSE(C2Param::Copy(btun));
    }

    const C2NumberPortTuning outp1(true, 100), inp1(false, 100);
    C2NumberPortTuning boutp1, binp1, binp3(false, 100);
    const C2NumberPortTuning::input inp2(100);
    C2NumberPortTuning::input binp2;
    const C2NumberPortTuning::output outp2(100);
    C2NumberPortTuning::output boutp2;

    EXPECT_EQ(inp1.coreIndex(), tun.coreIndex());
    EXPECT_EQ(outp1.coreIndex(), tun.coreIndex());
    EXPECT_EQ(binp1.coreIndex(), tun.coreIndex());
    EXPECT_EQ(boutp1.coreIndex(), tun.coreIndex());
    EXPECT_EQ(inp2.coreIndex(), tun.coreIndex());
    EXPECT_EQ(outp2.coreIndex(), tun.coreIndex());

    EXPECT_EQ(inp1.type(), inp2.type());
    EXPECT_EQ(outp1.type(), outp2.type());
    EXPECT_NE(inp1.type(), outp1.type());
    EXPECT_NE(inp2.type(), outp2.type());
    EXPECT_NE(inp1.type(), binp1.type());
    EXPECT_NE(outp1.type(), boutp1.type());
    EXPECT_NE(inp1.type(), tun.type());
    EXPECT_NE(inp2.type(), tun.type());

    {
        static_assert(canCallSetPort(binp3), "should be able to");
        static_assert(canCallSetPort(binp1), "should be able to");
        static_assert(!canCallSetPort(inp1), "should not be able to (const)");
        static_assert(!canCallSetPort(inp2), "should not be able to (const & type)");
        static_assert(!canCallSetPort(binp2), "should not be able to (type)");

        // flags & invariables
        for (const auto &p : { outp1, inp1, boutp1 }) {
            EXPECT_EQ(12u, p.size());
            EXPECT_FALSE(p.isVendor());
            EXPECT_FALSE(p.isFlexible());
            EXPECT_FALSE(p.isGlobal());
            EXPECT_FALSE(p.forStream());
            EXPECT_TRUE(p.forPort());
        }
        for (const auto &p : { inp2, binp2 }) {
            EXPECT_EQ(12u, p.size());
            EXPECT_FALSE(p.isVendor());
            EXPECT_FALSE(p.isFlexible());
            EXPECT_FALSE(p.isGlobal());
            EXPECT_FALSE(p.forStream());
            EXPECT_TRUE(p.forPort());
        }
        for (const auto &p : { outp2, boutp2 }) {
            EXPECT_EQ(12u, p.size());
            EXPECT_FALSE(p.isVendor());
            EXPECT_FALSE(p.isFlexible());
            EXPECT_FALSE(p.isGlobal());
            EXPECT_FALSE(p.forStream());
            EXPECT_TRUE(p.forPort());
        }

        // port specific flags & invariables
        EXPECT_FALSE(outp1.forInput());
        EXPECT_TRUE(outp1.forOutput());

        EXPECT_TRUE(inp1.forInput());
        EXPECT_FALSE(inp1.forOutput());

        for (const auto &p : { outp1, inp1 }) {
            EXPECT_TRUE((bool)p);
            EXPECT_FALSE(!p);
            EXPECT_EQ(100, p.mNumber);
        }
        for (const auto &p : { outp2, boutp2 }) {
            EXPECT_TRUE((bool)p);
            EXPECT_FALSE(!p);

            EXPECT_FALSE(p.forInput());
            EXPECT_TRUE(p.forOutput());
        }
        for (const auto &p : { inp2, binp2 }) {
            EXPECT_TRUE((bool)p);
            EXPECT_FALSE(!p);

            EXPECT_TRUE(p.forInput());
            EXPECT_FALSE(p.forOutput());
        }
        for (const auto &p : { boutp1 } ) {
            EXPECT_FALSE((bool)p);
            EXPECT_TRUE(!p);

            EXPECT_FALSE(p.forInput());
            EXPECT_FALSE(p.forOutput());
            EXPECT_EQ(0, p.mNumber);
        }

        // values
        EXPECT_EQ(100, inp2.mNumber);
        EXPECT_EQ(100, outp2.mNumber);
        EXPECT_EQ(0, binp1.mNumber);
        EXPECT_EQ(0, binp2.mNumber);
        EXPECT_EQ(0, boutp1.mNumber);
        EXPECT_EQ(0, boutp2.mNumber);

        EXPECT_TRUE(inp1 != outp1);
        EXPECT_TRUE(inp1 == inp2);
        EXPECT_TRUE(outp1 == outp2);
        EXPECT_TRUE(binp1 == boutp1);
        EXPECT_TRUE(binp2 != boutp2);

        EXPECT_TRUE(inp1 != binp1);
        binp1.mNumber = 100;
        EXPECT_TRUE(inp1 != binp1);
        binp1.setPort(false /* output */);
        EXPECT_TRUE((bool)binp1);
        EXPECT_FALSE(!binp1);
        EXPECT_TRUE(inp1 == binp1);

        EXPECT_TRUE(inp2 != binp2);
        binp2.mNumber = 100;
        EXPECT_TRUE(inp2 == binp2);

        binp1.setPort(true /* output */);
        EXPECT_TRUE(outp1 == binp1);

        EXPECT_TRUE(outp1 != boutp1);
        boutp1.mNumber = 100;
        EXPECT_TRUE(outp1 != boutp1);
        boutp1.setPort(true /* output */);
        EXPECT_TRUE((bool)boutp1);
        EXPECT_FALSE(!boutp1);
        EXPECT_TRUE(outp1 == boutp1);

        EXPECT_TRUE(outp2 != boutp2);
        boutp2.mNumber = 100;
        EXPECT_TRUE(outp2 == boutp2);

        boutp1.setPort(false /* output */);
        EXPECT_TRUE(inp1 == boutp1);

        // index
        EXPECT_EQ(C2Param::Type(inp1.type()).coreIndex(), C2NumberStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(inp1.type()).typeIndex(), kParamIndexNumber);
        EXPECT_EQ(inp1.type(), C2NumberPortTuning::input::PARAM_TYPE);
        EXPECT_EQ(inp1.stream(), ~0u);

        EXPECT_EQ(C2Param::Type(inp2.type()).coreIndex(), C2NumberStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(inp2.type()).typeIndex(), kParamIndexNumber);
        EXPECT_EQ(inp2.type(), C2NumberPortTuning::input::PARAM_TYPE);
        EXPECT_EQ(inp2.stream(), ~0u);

        EXPECT_EQ(C2Param::Type(outp1.type()).coreIndex(), C2NumberStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(outp1.type()).typeIndex(), kParamIndexNumber);
        EXPECT_EQ(outp1.type(), C2NumberPortTuning::output::PARAM_TYPE);
        EXPECT_EQ(outp1.stream(), ~0u);

        EXPECT_EQ(C2Param::Type(outp2.type()).coreIndex(), C2NumberStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(outp2.type()).typeIndex(), kParamIndexNumber);
        EXPECT_EQ(outp2.type(), C2NumberPortTuning::output::PARAM_TYPE);
        EXPECT_EQ(outp2.stream(), ~0u);

        C2Param::CoreIndex index = C2NumberPortTuning::input::PARAM_TYPE;
        EXPECT_FALSE(index.isVendor());
        EXPECT_FALSE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumber);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumber);

        index = C2NumberPortTuning::output::PARAM_TYPE;
        EXPECT_FALSE(index.isVendor());
        EXPECT_FALSE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumber);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumber);

        C2Param::Type type = C2NumberPortTuning::input::PARAM_TYPE;
        EXPECT_FALSE(type.isVendor());
        EXPECT_FALSE(type.isFlexible());
        EXPECT_FALSE(type.isGlobal());
        EXPECT_TRUE(type.forInput());
        EXPECT_FALSE(type.forOutput());
        EXPECT_FALSE(type.forStream());
        EXPECT_TRUE(type.forPort());

        type = C2NumberPortTuning::output::PARAM_TYPE;
        EXPECT_FALSE(type.isVendor());
        EXPECT_FALSE(type.isFlexible());
        EXPECT_FALSE(type.isGlobal());
        EXPECT_FALSE(type.forInput());
        EXPECT_TRUE(type.forOutput());
        EXPECT_FALSE(type.forStream());
        EXPECT_TRUE(type.forPort());

        EXPECT_EQ(C2NumberPortTuning::From(nullptr), nullptr);
        EXPECT_EQ(C2NumberPortTuning::input::From(nullptr), nullptr);
        EXPECT_EQ(C2NumberPortTuning::output::From(nullptr), nullptr);
        EXPECT_EQ(C2NumberTuning::From(&inp1), nullptr);
        EXPECT_EQ(C2NumberTuning::From(&inp2), nullptr);
        EXPECT_EQ(C2NumberTuning::From(&outp1), nullptr);
        EXPECT_EQ(C2NumberTuning::From(&outp2), nullptr);
        EXPECT_EQ(C2NumberPortTuning::From(&inp1), &inp1);
        EXPECT_EQ(C2NumberPortTuning::From(&inp2), (C2NumberPortTuning*)&inp2);
        EXPECT_EQ(C2NumberPortTuning::From(&outp1), &outp1);
        EXPECT_EQ(C2NumberPortTuning::From(&outp2), (C2NumberPortTuning*)&outp2);
        EXPECT_EQ(C2NumberPortTuning::input::From(&inp1), (C2NumberPortTuning::input*)&inp1);
        EXPECT_EQ(C2NumberPortTuning::input::From(&inp2), &inp2);
        EXPECT_EQ(C2NumberPortTuning::input::From(&outp1), nullptr);
        EXPECT_EQ(C2NumberPortTuning::input::From(&outp2), nullptr);
        EXPECT_EQ(C2NumberPortTuning::output::From(&inp1), nullptr);
        EXPECT_EQ(C2NumberPortTuning::output::From(&inp2), nullptr);
        EXPECT_EQ(C2NumberPortTuning::output::From(&outp1), (C2NumberPortTuning::output*)&outp1);
        EXPECT_EQ(C2NumberPortTuning::output::From(&outp2), &outp2);
        EXPECT_EQ(C2NumberStreamTuning::From(&inp1), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::From(&inp2), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::From(&outp1), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::From(&outp2), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::input::From(&inp1), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::input::From(&inp2), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::input::From(&outp1), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::input::From(&outp2), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::output::From(&inp1), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::output::From(&inp2), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::output::From(&outp1), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::output::From(&outp2), nullptr);

        EXPECT_EQ(*(C2Param::Copy(inp1)), inp1);
        EXPECT_EQ(*(C2Param::Copy(inp2)), inp2);
        EXPECT_EQ(*(C2Param::Copy(outp1)), outp1);
        EXPECT_EQ(*(C2Param::Copy(outp2)), outp2);
    }

    const C2NumberStreamTuning outs1(true, 1u, 100), ins1(false, 1u, 100);
    C2NumberStreamTuning bouts1, bins1, bins3(false, 1u, 100);
    const C2NumberStreamTuning::input ins2(1u, 100);
    C2NumberStreamTuning::input bins2;
    const C2NumberStreamTuning::output outs2(1u, 100);
    C2NumberStreamTuning::output bouts2;

    EXPECT_EQ(ins1.coreIndex(), tun.coreIndex());
    EXPECT_EQ(outs1.coreIndex(), tun.coreIndex());
    EXPECT_EQ(bins1.coreIndex(), tun.coreIndex());
    EXPECT_EQ(bouts1.coreIndex(), tun.coreIndex());
    EXPECT_EQ(ins2.coreIndex(), tun.coreIndex());
    EXPECT_EQ(outs2.coreIndex(), tun.coreIndex());

    EXPECT_EQ(ins1.type(), ins2.type());
    EXPECT_EQ(ins1.type(), bins2.type());
    EXPECT_EQ(outs1.type(), outs2.type());
    EXPECT_EQ(outs1.type(), bouts2.type());
    EXPECT_NE(ins1.type(), outs1.type());
    EXPECT_NE(ins2.type(), outs2.type());
    EXPECT_NE(ins1.type(), bins1.type());
    EXPECT_NE(outs1.type(), bouts1.type());
    EXPECT_NE(ins1.type(), tun.type());
    EXPECT_NE(ins2.type(), tun.type());

    {
        static_assert(canCallSetPort(bins3), "should be able to");
        static_assert(canCallSetPort(bins1), "should be able to");
        static_assert(!canCallSetPort(ins1), "should not be able to (const)");
        static_assert(!canCallSetPort(ins2), "should not be able to (const & type)");
        static_assert(!canCallSetPort(bins2), "should not be able to (type)");

        // flags & invariables
        for (const auto &p : { outs1, ins1, bouts1 }) {
            EXPECT_EQ(12u, p.size());
            EXPECT_FALSE(p.isVendor());
            EXPECT_FALSE(p.isFlexible());
            EXPECT_FALSE(p.isGlobal());
            EXPECT_TRUE(p.forStream());
            EXPECT_FALSE(p.forPort());
        }
        for (const auto &p : { ins2, bins2 }) {
            EXPECT_EQ(12u, p.size());
            EXPECT_FALSE(p.isVendor());
            EXPECT_FALSE(p.isFlexible());
            EXPECT_FALSE(p.isGlobal());
            EXPECT_TRUE(p.forStream());
            EXPECT_FALSE(p.forPort());
        }
        for (const auto &p : { outs2, bouts2 }) {
            EXPECT_EQ(12u, p.size());
            EXPECT_FALSE(p.isVendor());
            EXPECT_FALSE(p.isFlexible());
            EXPECT_FALSE(p.isGlobal());
            EXPECT_TRUE(p.forStream());
            EXPECT_FALSE(p.forPort());
        }

        // port specific flags & invariables
        EXPECT_FALSE(outs1.forInput());
        EXPECT_TRUE(outs1.forOutput());

        EXPECT_TRUE(ins1.forInput());
        EXPECT_FALSE(ins1.forOutput());

        for (const auto &p : { outs1, ins1 }) {
            EXPECT_TRUE((bool)p);
            EXPECT_FALSE(!p);
            EXPECT_EQ(100, p.mNumber);
            EXPECT_EQ(1u, p.stream());
        }
        for (const auto &p : { outs2, bouts2 }) {
            EXPECT_TRUE((bool)p);
            EXPECT_FALSE(!p);

            EXPECT_FALSE(p.forInput());
            EXPECT_TRUE(p.forOutput());
        }
        for (const auto &p : { ins2, bins2 }) {
            EXPECT_TRUE((bool)p);
            EXPECT_FALSE(!p);

            EXPECT_TRUE(p.forInput());
            EXPECT_FALSE(p.forOutput());
        }
        for (const auto &p : { bouts1 } ) {
            EXPECT_FALSE((bool)p);
            EXPECT_TRUE(!p);

            EXPECT_FALSE(p.forInput());
            EXPECT_FALSE(p.forOutput());
            EXPECT_EQ(0, p.mNumber);
        }

        // values
        EXPECT_EQ(100, ins2.mNumber);
        EXPECT_EQ(100, outs2.mNumber);
        EXPECT_EQ(0, bins1.mNumber);
        EXPECT_EQ(0, bins2.mNumber);
        EXPECT_EQ(0, bouts1.mNumber);
        EXPECT_EQ(0, bouts2.mNumber);

        EXPECT_EQ(1u, ins2.stream());
        EXPECT_EQ(1u, outs2.stream());
        EXPECT_EQ(0u, bins1.stream());
        EXPECT_EQ(0u, bins2.stream());
        EXPECT_EQ(0u, bouts1.stream());
        EXPECT_EQ(0u, bouts2.stream());

        EXPECT_TRUE(ins1 != outs1);
        EXPECT_TRUE(ins1 == ins2);
        EXPECT_TRUE(outs1 == outs2);
        EXPECT_TRUE(bins1 == bouts1);
        EXPECT_TRUE(bins2 != bouts2);

        EXPECT_TRUE(ins1 != bins1);
        bins1.mNumber = 100;
        EXPECT_TRUE(ins1 != bins1);
        bins1.setPort(false /* output */);
        EXPECT_TRUE(ins1 != bins1);
        bins1.setStream(1u);
        EXPECT_TRUE(ins1 == bins1);

        EXPECT_TRUE(ins2 != bins2);
        bins2.mNumber = 100;
        EXPECT_TRUE(ins2 != bins2);
        bins2.setStream(1u);
        EXPECT_TRUE(ins2 == bins2);

        bins1.setPort(true /* output */);
        EXPECT_TRUE(outs1 == bins1);

        EXPECT_TRUE(outs1 != bouts1);
        bouts1.mNumber = 100;
        EXPECT_TRUE(outs1 != bouts1);
        bouts1.setPort(true /* output */);
        EXPECT_TRUE(outs1 != bouts1);
        bouts1.setStream(1u);
        EXPECT_TRUE(outs1 == bouts1);

        EXPECT_TRUE(outs2 != bouts2);
        bouts2.mNumber = 100;
        EXPECT_TRUE(outs2 != bouts2);
        bouts2.setStream(1u);
        EXPECT_TRUE(outs2 == bouts2);

        bouts1.setPort(false /* output */);
        EXPECT_TRUE(ins1 == bouts1);

        // index
        EXPECT_EQ(C2Param::Type(ins1.type()).coreIndex(), C2NumberStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(ins1.type()).typeIndex(), kParamIndexNumber);
        EXPECT_EQ(ins1.type(), C2NumberStreamTuning::input::PARAM_TYPE);

        EXPECT_EQ(C2Param::Type(ins2.type()).coreIndex(), C2NumberStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(ins2.type()).typeIndex(), kParamIndexNumber);
        EXPECT_EQ(ins2.type(), C2NumberStreamTuning::input::PARAM_TYPE);

        EXPECT_EQ(C2Param::Type(outs1.type()).coreIndex(), C2NumberStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(outs1.type()).typeIndex(), kParamIndexNumber);
        EXPECT_EQ(outs1.type(), C2NumberStreamTuning::output::PARAM_TYPE);

        EXPECT_EQ(C2Param::Type(outs2.type()).coreIndex(), C2NumberStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(outs2.type()).typeIndex(), kParamIndexNumber);
        EXPECT_EQ(outs2.type(), C2NumberStreamTuning::output::PARAM_TYPE);

        C2Param::CoreIndex index = C2NumberStreamTuning::input::PARAM_TYPE;
        EXPECT_FALSE(index.isVendor());
        EXPECT_FALSE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumber);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumber);

        index = C2NumberStreamTuning::output::PARAM_TYPE;
        EXPECT_FALSE(index.isVendor());
        EXPECT_FALSE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumber);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumber);

        C2Param::Type type = C2NumberStreamTuning::input::PARAM_TYPE;
        EXPECT_FALSE(type.isVendor());
        EXPECT_FALSE(type.isFlexible());
        EXPECT_FALSE(type.isGlobal());
        EXPECT_TRUE(type.forInput());
        EXPECT_FALSE(type.forOutput());
        EXPECT_TRUE(type.forStream());
        EXPECT_FALSE(type.forPort());

        type = C2NumberStreamTuning::output::PARAM_TYPE;
        EXPECT_FALSE(type.isVendor());
        EXPECT_FALSE(type.isFlexible());
        EXPECT_FALSE(type.isGlobal());
        EXPECT_FALSE(type.forInput());
        EXPECT_TRUE(type.forOutput());
        EXPECT_TRUE(type.forStream());
        EXPECT_FALSE(type.forPort());

        EXPECT_EQ(C2NumberPortTuning::From(nullptr), nullptr);
        EXPECT_EQ(C2NumberPortTuning::input::From(nullptr), nullptr);
        EXPECT_EQ(C2NumberPortTuning::output::From(nullptr), nullptr);
        EXPECT_EQ(C2NumberTuning::From(&ins1), nullptr);
        EXPECT_EQ(C2NumberTuning::From(&ins2), nullptr);
        EXPECT_EQ(C2NumberTuning::From(&outs1), nullptr);
        EXPECT_EQ(C2NumberTuning::From(&outs2), nullptr);
        EXPECT_EQ(C2NumberPortTuning::From(&ins1), nullptr);
        EXPECT_EQ(C2NumberPortTuning::From(&ins2), nullptr);
        EXPECT_EQ(C2NumberPortTuning::From(&outs1), nullptr);
        EXPECT_EQ(C2NumberPortTuning::From(&outs2), nullptr);
        EXPECT_EQ(C2NumberPortTuning::input::From(&ins1), nullptr);
        EXPECT_EQ(C2NumberPortTuning::input::From(&ins2), nullptr);
        EXPECT_EQ(C2NumberPortTuning::input::From(&outs1), nullptr);
        EXPECT_EQ(C2NumberPortTuning::input::From(&outs2), nullptr);
        EXPECT_EQ(C2NumberPortTuning::output::From(&ins1), nullptr);
        EXPECT_EQ(C2NumberPortTuning::output::From(&ins2), nullptr);
        EXPECT_EQ(C2NumberPortTuning::output::From(&outs1), nullptr);
        EXPECT_EQ(C2NumberPortTuning::output::From(&outs2), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::From(&ins1), &ins1);
        EXPECT_EQ(C2NumberStreamTuning::From(&ins2), (C2NumberStreamTuning*)&ins2);
        EXPECT_EQ(C2NumberStreamTuning::From(&outs1), &outs1);
        EXPECT_EQ(C2NumberStreamTuning::From(&outs2), (C2NumberStreamTuning*)&outs2);
        EXPECT_EQ(C2NumberStreamTuning::input::From(&ins1), (C2NumberStreamTuning::input*)&ins1);
        EXPECT_EQ(C2NumberStreamTuning::input::From(&ins2), &ins2);
        EXPECT_EQ(C2NumberStreamTuning::input::From(&outs1), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::input::From(&outs2), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::output::From(&ins1), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::output::From(&ins2), nullptr);
        EXPECT_EQ(C2NumberStreamTuning::output::From(&outs1), (C2NumberStreamTuning::output*)&outs1);
        EXPECT_EQ(C2NumberStreamTuning::output::From(&outs2), &outs2);

        EXPECT_EQ(*(C2Param::Copy(ins1)), ins1);
        EXPECT_EQ(*(C2Param::Copy(ins2)), ins2);
        EXPECT_EQ(*(C2Param::Copy(outs1)), outs1);
        EXPECT_EQ(*(C2Param::Copy(outs2)), outs2);
    }

    {
        uint32_t videoWidth[] = { 12u, C2NumberStreamTuning::output::PARAM_TYPE, 100 };
        C2Param *p1 = C2Param::From(videoWidth, sizeof(videoWidth));
        EXPECT_NE(p1, nullptr);
        EXPECT_EQ(12u, p1->size());
        EXPECT_EQ(p1->type(), C2NumberStreamTuning::output::PARAM_TYPE);

        p1 = C2Param::From(videoWidth, sizeof(videoWidth) + 2);
        EXPECT_EQ(p1, nullptr);

        p1 = C2Param::From(videoWidth, sizeof(videoWidth) - 2);
        EXPECT_EQ(p1, nullptr);

        p1 = C2Param::From(videoWidth, 3);
        EXPECT_EQ(p1, nullptr);

        p1 = C2Param::From(videoWidth, 0);
        EXPECT_EQ(p1, nullptr);
    }
}

void StaticTestAddCoreIndex() {
    struct nobase {};
    struct base { enum : uint32_t { CORE_INDEX = 1 }; };
    static_assert(_C2AddCoreIndex<nobase, 2>::CORE_INDEX == 2, "should be 2");
    static_assert(_C2AddCoreIndex<base, 1>::CORE_INDEX == 1, "should be 1");
}

class TestFlexHelper {
    struct _Flex {
        int32_t a;
        char b[];
        _Flex() {}
        FLEX(_Flex, b);
    };

    struct _BoFlex {
        _Flex a;
        _BoFlex() {}
        FLEX(_BoFlex, a);
    };

    struct _NonFlex {
    };


    static void StaticTest() {
        static_assert(std::is_same<_C2FlexHelper<char>::FlexType, void>::value, "should be void");
        static_assert(std::is_same<_C2FlexHelper<char[]>::FlexType, char>::value, "should be char");
        static_assert(std::is_same<_C2FlexHelper<_Flex>::FlexType, char>::value, "should be char");

        static_assert(std::is_same<_C2FlexHelper<_BoFlex>::FlexType, char>::value, "should be void");

        static_assert(_C2Flexible<_Flex>::value, "should be flexible");
        static_assert(!_C2Flexible<_NonFlex>::value, "should not be flexible");
    }
};

TEST_F(C2ParamTest, FlexParamOpsTest) {
//    const C2NumbersStruct str{100};
    C2NumbersStruct bstr;
    {
//        EXPECT_EQ(100, str->m.mNumbers[0]);
        (void)&bstr.mNumbers[0];

        C2Param::CoreIndex index = C2NumbersStruct::CORE_INDEX;
        EXPECT_FALSE(index.isVendor());
        EXPECT_TRUE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumbers | C2Param::CoreIndex::IS_FLEX_FLAG);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumbers);
    }

    std::unique_ptr<C2NumbersTuning> tun_ = C2NumbersTuning::AllocUnique(1);
    tun_->m.mNumbers[0] = 100;
    std::unique_ptr<const C2NumbersTuning> tun = std::move(tun_);
    std::shared_ptr<C2NumbersTuning> btun = C2NumbersTuning::AllocShared(1);

    {
        // flags & invariables
        const C2NumbersTuning *T[] = { tun.get(), btun.get() };
        for (const auto p : T) {
            EXPECT_TRUE((bool)(*p));
            EXPECT_FALSE(!(*p));
            EXPECT_EQ(12u, p->size());

            EXPECT_FALSE(p->isVendor());
            EXPECT_TRUE(p->isFlexible());
            EXPECT_TRUE(p->isGlobal());
            EXPECT_FALSE(p->forInput());
            EXPECT_FALSE(p->forOutput());
            EXPECT_FALSE(p->forStream());
            EXPECT_FALSE(p->forPort());
        }

        // value
        EXPECT_EQ(100, tun->m.mNumbers[0]);
        EXPECT_EQ(0, btun->m.mNumbers[0]);
        EXPECT_FALSE(*tun == *btun);
        EXPECT_FALSE(tun->operator==(*btun));
        EXPECT_TRUE(*tun != *btun);
        EXPECT_TRUE(tun->operator!=(*btun));
        btun->m.mNumbers[0] = 100;
        EXPECT_EQ(*tun, *btun);

        // index
        EXPECT_EQ(C2Param::Type(tun->type()).coreIndex(), C2NumbersStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(tun->type()).typeIndex(), kParamIndexNumbers);
        EXPECT_EQ(tun->type(), C2NumbersTuning::PARAM_TYPE);
        EXPECT_EQ(tun->stream(), ~0u);

        C2Param::CoreIndex index = C2NumbersTuning::CORE_INDEX;
        EXPECT_FALSE(index.isVendor());
        EXPECT_TRUE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumbers | C2Param::CoreIndex::IS_FLEX_FLAG);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumbers);

        C2Param::Type type = C2NumbersTuning::PARAM_TYPE;
        EXPECT_FALSE(type.isVendor());
        EXPECT_TRUE(type.isFlexible());
        EXPECT_TRUE(type.isGlobal());
        EXPECT_FALSE(type.forInput());
        EXPECT_FALSE(type.forOutput());
        EXPECT_FALSE(type.forStream());
        EXPECT_FALSE(type.forPort());

        EXPECT_EQ(C2NumbersTuning::From(nullptr), nullptr);
        EXPECT_EQ(C2NumbersTuning::From(tun.get()), tun.get());
        EXPECT_EQ(C2NumbersPortTuning::From(tun.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::input::From(tun.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::output::From(tun.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::From(tun.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::input::From(tun.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::output::From(tun.get()), nullptr);

        EXPECT_EQ(*(C2Param::Copy(*tun)), *tun);
    }

    std::unique_ptr<C2NumbersPortTuning> outp1_(C2NumbersPortTuning::AllocUnique(1, true)),
            inp1_ = C2NumbersPortTuning::AllocUnique(1, false);
    outp1_->m.mNumbers[0] = 100;
    inp1_->m.mNumbers[0] = 100;
    std::unique_ptr<const C2NumbersPortTuning> outp1 = std::move(outp1_);
    std::unique_ptr<const C2NumbersPortTuning> inp1 = std::move(inp1_);
    std::shared_ptr<C2NumbersPortTuning> boutp1(C2NumbersPortTuning::AllocShared(1)),
            binp1 = C2NumbersPortTuning::AllocShared(1),
            binp3 = C2NumbersPortTuning::AllocShared(1, false);
    binp3->m.mNumbers[0] = 100;
    std::unique_ptr<C2NumbersPortTuning::input> inp2_(C2NumbersPortTuning::input::AllocUnique(1));
    inp2_->m.mNumbers[0] = 100;
    std::unique_ptr<const C2NumbersPortTuning::input> inp2 = std::move(inp2_);
    std::shared_ptr<C2NumbersPortTuning::input> binp2(C2NumbersPortTuning::input::AllocShared(1));
    std::unique_ptr<C2NumbersPortTuning::output> outp2_(C2NumbersPortTuning::output::AllocUnique(1));
    outp2_->m.mNumbers[0] = 100;
    std::unique_ptr<const C2NumbersPortTuning::output> outp2 = std::move(outp2_);
    std::shared_ptr<C2NumbersPortTuning::output> boutp2(C2NumbersPortTuning::output::AllocShared(1));

    {
        static_assert(canCallSetPort(*binp3), "should be able to");
        static_assert(canCallSetPort(*binp1), "should be able to");
        static_assert(!canCallSetPort(*inp1), "should not be able to (const)");
        static_assert(!canCallSetPort(*inp2), "should not be able to (const & type)");
        static_assert(!canCallSetPort(*binp2), "should not be able to (type)");

        // flags & invariables
        const C2NumbersPortTuning *P[] = { outp1.get(), inp1.get(), boutp1.get() };
        for (const auto p : P) {
            EXPECT_EQ(12u, p->size());
            EXPECT_FALSE(p->isVendor());
            EXPECT_TRUE(p->isFlexible());
            EXPECT_FALSE(p->isGlobal());
            EXPECT_FALSE(p->forStream());
            EXPECT_TRUE(p->forPort());
        }
        const C2NumbersPortTuning::input *PI[] = { inp2.get(), binp2.get() };
        for (const auto p : PI) {
            EXPECT_EQ(12u, p->size());
            EXPECT_FALSE(p->isVendor());
            EXPECT_TRUE(p->isFlexible());
            EXPECT_FALSE(p->isGlobal());
            EXPECT_FALSE(p->forStream());
            EXPECT_TRUE(p->forPort());
        }
        const C2NumbersPortTuning::output *PO[] = { outp2.get(), boutp2.get() };
        for (const auto p : PO) {
            EXPECT_EQ(12u, p->size());
            EXPECT_FALSE(p->isVendor());
            EXPECT_TRUE(p->isFlexible());
            EXPECT_FALSE(p->isGlobal());
            EXPECT_FALSE(p->forStream());
            EXPECT_TRUE(p->forPort());
        }

        // port specific flags & invariables
        EXPECT_FALSE(outp1->forInput());
        EXPECT_TRUE(outp1->forOutput());

        EXPECT_TRUE(inp1->forInput());
        EXPECT_FALSE(inp1->forOutput());

        const C2NumbersPortTuning *P2[] = { outp1.get(), inp1.get() };
        for (const auto p : P2) {
            EXPECT_TRUE((bool)(*p));
            EXPECT_FALSE(!(*p));
            EXPECT_EQ(100, p->m.mNumbers[0]);
        }
        for (const auto p : PO) {
            EXPECT_TRUE((bool)(*p));
            EXPECT_FALSE(!(*p));

            EXPECT_FALSE(p->forInput());
            EXPECT_TRUE(p->forOutput());
        }
        for (const auto p : PI) {
            EXPECT_TRUE((bool)(*p));
            EXPECT_FALSE(!(*p));

            EXPECT_TRUE(p->forInput());
            EXPECT_FALSE(p->forOutput());
        }
        const C2NumbersPortTuning *P3[] = { boutp1.get() };
        for (const auto p : P3) {
            EXPECT_FALSE((bool)(*p));
            EXPECT_TRUE(!(*p));

            EXPECT_FALSE(p->forInput());
            EXPECT_FALSE(p->forOutput());
            EXPECT_EQ(0, p->m.mNumbers[0]);
        }

        // values
        EXPECT_EQ(100, inp2->m.mNumbers[0]);
        EXPECT_EQ(100, outp2->m.mNumbers[0]);
        EXPECT_EQ(0, binp1->m.mNumbers[0]);
        EXPECT_EQ(0, binp2->m.mNumbers[0]);
        EXPECT_EQ(0, boutp1->m.mNumbers[0]);
        EXPECT_EQ(0, boutp2->m.mNumbers[0]);

        EXPECT_TRUE(*inp1 != *outp1);
        EXPECT_TRUE(*inp1 == *inp2);
        EXPECT_TRUE(*outp1 == *outp2);
        EXPECT_TRUE(*binp1 == *boutp1);
        EXPECT_TRUE(*binp2 != *boutp2);

        EXPECT_TRUE(*inp1 != *binp1);
        binp1->m.mNumbers[0] = 100;
        EXPECT_TRUE(*inp1 != *binp1);
        binp1->setPort(false /* output */);
        EXPECT_TRUE((bool)*binp1);
        EXPECT_FALSE(!*binp1);
        EXPECT_TRUE(*inp1 == *binp1);

        EXPECT_TRUE(*inp2 != *binp2);
        binp2->m.mNumbers[0] = 100;
        EXPECT_TRUE(*inp2 == *binp2);

        binp1->setPort(true /* output */);
        EXPECT_TRUE(*outp1 == *binp1);

        EXPECT_TRUE(*outp1 != *boutp1);
        boutp1->m.mNumbers[0] = 100;
        EXPECT_TRUE(*outp1 != *boutp1);
        boutp1->setPort(true /* output */);
        EXPECT_TRUE((bool)*boutp1);
        EXPECT_FALSE(!*boutp1);
        EXPECT_TRUE(*outp1 == *boutp1);

        EXPECT_TRUE(*outp2 != *boutp2);
        boutp2->m.mNumbers[0] = 100;
        EXPECT_TRUE(*outp2 == *boutp2);

        boutp1->setPort(false /* output */);
        EXPECT_TRUE(*inp1 == *boutp1);

        // index
        EXPECT_EQ(C2Param::Type(inp1->type()).coreIndex(), C2NumbersStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(inp1->type()).typeIndex(), kParamIndexNumbers);
        EXPECT_EQ(inp1->type(), C2NumbersPortTuning::input::PARAM_TYPE);
        EXPECT_EQ(inp1->stream(), ~0u);

        EXPECT_EQ(C2Param::Type(inp2->type()).coreIndex(), C2NumbersStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(inp2->type()).typeIndex(), kParamIndexNumbers);
        EXPECT_EQ(inp2->type(), C2NumbersPortTuning::input::PARAM_TYPE);
        EXPECT_EQ(inp2->stream(), ~0u);

        EXPECT_EQ(C2Param::Type(outp1->type()).coreIndex(), C2NumbersStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(outp1->type()).typeIndex(), kParamIndexNumbers);
        EXPECT_EQ(outp1->type(), C2NumbersPortTuning::output::PARAM_TYPE);
        EXPECT_EQ(outp1->stream(), ~0u);

        EXPECT_EQ(C2Param::Type(outp2->type()).coreIndex(), C2NumbersStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(outp2->type()).typeIndex(), kParamIndexNumbers);
        EXPECT_EQ(outp2->type(), C2NumbersPortTuning::output::PARAM_TYPE);
        EXPECT_EQ(outp2->stream(), ~0u);

        C2Param::CoreIndex index = C2NumbersPortTuning::input::PARAM_TYPE;
        EXPECT_FALSE(index.isVendor());
        EXPECT_TRUE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumbers | C2Param::CoreIndex::IS_FLEX_FLAG);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumbers);

        index = C2NumbersPortTuning::output::PARAM_TYPE;
        EXPECT_FALSE(index.isVendor());
        EXPECT_TRUE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumbers | C2Param::CoreIndex::IS_FLEX_FLAG);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumbers);

        C2Param::Type type = C2NumbersPortTuning::input::PARAM_TYPE;
        EXPECT_FALSE(type.isVendor());
        EXPECT_TRUE(type.isFlexible());
        EXPECT_FALSE(type.isGlobal());
        EXPECT_TRUE(type.forInput());
        EXPECT_FALSE(type.forOutput());
        EXPECT_FALSE(type.forStream());
        EXPECT_TRUE(type.forPort());

        type = C2NumbersPortTuning::output::PARAM_TYPE;
        EXPECT_FALSE(type.isVendor());
        EXPECT_TRUE(type.isFlexible());
        EXPECT_FALSE(type.isGlobal());
        EXPECT_FALSE(type.forInput());
        EXPECT_TRUE(type.forOutput());
        EXPECT_FALSE(type.forStream());
        EXPECT_TRUE(type.forPort());

        EXPECT_EQ(C2NumbersPortTuning::From(nullptr), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::input::From(nullptr), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::output::From(nullptr), nullptr);
        EXPECT_EQ(C2NumbersTuning::From(inp1.get()), nullptr);
        EXPECT_EQ(C2NumbersTuning::From(inp2.get()), nullptr);
        EXPECT_EQ(C2NumbersTuning::From(outp1.get()), nullptr);
        EXPECT_EQ(C2NumbersTuning::From(outp2.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::From(inp1.get()), inp1.get());
        EXPECT_EQ(C2NumbersPortTuning::From(inp2.get()), (C2NumbersPortTuning*)inp2.get());
        EXPECT_EQ(C2NumbersPortTuning::From(outp1.get()), outp1.get());
        EXPECT_EQ(C2NumbersPortTuning::From(outp2.get()), (C2NumbersPortTuning*)outp2.get());
        EXPECT_EQ(C2NumbersPortTuning::input::From(inp1.get()), (C2NumbersPortTuning::input*)inp1.get());
        EXPECT_EQ(C2NumbersPortTuning::input::From(inp2.get()), inp2.get());
        EXPECT_EQ(C2NumbersPortTuning::input::From(outp1.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::input::From(outp2.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::output::From(inp1.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::output::From(inp2.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::output::From(outp1.get()), (C2NumbersPortTuning::output*)outp1.get());
        EXPECT_EQ(C2NumbersPortTuning::output::From(outp2.get()), outp2.get());
        EXPECT_EQ(C2NumbersStreamTuning::From(inp1.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::From(inp2.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::From(outp1.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::From(outp2.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::input::From(inp1.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::input::From(inp2.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::input::From(outp1.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::input::From(outp2.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::output::From(inp1.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::output::From(inp2.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::output::From(outp1.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::output::From(outp2.get()), nullptr);

        EXPECT_EQ(*(C2Param::Copy(*inp1)), *inp1);
        EXPECT_EQ(*(C2Param::Copy(*inp2)), *inp2);
        EXPECT_EQ(*(C2Param::Copy(*outp1)), *outp1);
        EXPECT_EQ(*(C2Param::Copy(*outp2)), *outp2);
    }

    std::unique_ptr<C2NumbersStreamTuning> outs1_(C2NumbersStreamTuning::AllocUnique(1, true, 1u));
    outs1_->m.mNumbers[0] = 100;
    std::unique_ptr<const C2NumbersStreamTuning> outs1 = std::move(outs1_);
    std::unique_ptr<C2NumbersStreamTuning> ins1_(C2NumbersStreamTuning::AllocUnique(1, false, 1u));
    ins1_->m.mNumbers[0] = 100;
    std::unique_ptr<const C2NumbersStreamTuning> ins1 = std::move(ins1_);
    std::shared_ptr<C2NumbersStreamTuning> bouts1(C2NumbersStreamTuning::AllocShared(1));
    std::shared_ptr<C2NumbersStreamTuning> bins1(C2NumbersStreamTuning::AllocShared(1));
    std::shared_ptr<C2NumbersStreamTuning> bins3(C2NumbersStreamTuning::AllocShared(1, false, 1u));
    bins3->m.mNumbers[0] = 100;
    std::unique_ptr<C2NumbersStreamTuning::input> ins2_(C2NumbersStreamTuning::input::AllocUnique(1, 1u));
    ins2_->m.mNumbers[0] = 100;
    std::unique_ptr<const C2NumbersStreamTuning::input> ins2 = std::move(ins2_);
    std::shared_ptr<C2NumbersStreamTuning::input> bins2(C2NumbersStreamTuning::input::AllocShared(1));
    std::unique_ptr<C2NumbersStreamTuning::output> outs2_(C2NumbersStreamTuning::output::AllocUnique(1, 1u));
    outs2_->m.mNumbers[0] = 100;
    std::unique_ptr<const C2NumbersStreamTuning::output> outs2 = std::move(outs2_);
    std::shared_ptr<C2NumbersStreamTuning::output> bouts2(C2NumbersStreamTuning::output::AllocShared(1));

    {
        static_assert(canCallSetPort(*bins3), "should be able to");
        static_assert(canCallSetPort(*bins1), "should be able to");
        static_assert(!canCallSetPort(*ins1), "should not be able to (const)");
        static_assert(!canCallSetPort(*ins2), "should not be able to (const & type)");
        static_assert(!canCallSetPort(*bins2), "should not be able to (type)");

        // flags & invariables
        const C2NumbersStreamTuning *S[] = { outs1.get(), ins1.get(), bouts1.get() };
        for (const auto p : S) {
            EXPECT_EQ(12u, p->size());
            EXPECT_FALSE(p->isVendor());
            EXPECT_TRUE(p->isFlexible());
            EXPECT_FALSE(p->isGlobal());
            EXPECT_TRUE(p->forStream());
            EXPECT_FALSE(p->forPort());
        }
        const C2NumbersStreamTuning::input *SI[] = { ins2.get(), bins2.get() };
        for (const auto p : SI) {
            EXPECT_EQ(12u, p->size());
            EXPECT_FALSE(p->isVendor());
            EXPECT_TRUE(p->isFlexible());
            EXPECT_FALSE(p->isGlobal());
            EXPECT_TRUE(p->forStream());
            EXPECT_FALSE(p->forPort());
        }
        const C2NumbersStreamTuning::output *SO[] = { outs2.get(), bouts2.get() };
        for (const auto p : SO) {
            EXPECT_EQ(12u, p->size());
            EXPECT_FALSE(p->isVendor());
            EXPECT_TRUE(p->isFlexible());
            EXPECT_FALSE(p->isGlobal());
            EXPECT_TRUE(p->forStream());
            EXPECT_FALSE(p->forPort());
        }

        // port specific flags & invariables
        EXPECT_FALSE(outs1->forInput());
        EXPECT_TRUE(outs1->forOutput());

        EXPECT_TRUE(ins1->forInput());
        EXPECT_FALSE(ins1->forOutput());

        const C2NumbersStreamTuning *S2[] = { outs1.get(), ins1.get() };
        for (const auto p : S2) {
            EXPECT_TRUE((bool)(*p));
            EXPECT_FALSE(!(*p));
            EXPECT_EQ(100, p->m.mNumbers[0]);
            EXPECT_EQ(1u, p->stream());
        }
        for (const auto p : SO) {
            EXPECT_TRUE((bool)(*p));
            EXPECT_FALSE(!(*p));

            EXPECT_FALSE(p->forInput());
            EXPECT_TRUE(p->forOutput());
        }
        for (const auto p : SI) {
            EXPECT_TRUE((bool)(*p));
            EXPECT_FALSE(!(*p));

            EXPECT_TRUE(p->forInput());
            EXPECT_FALSE(p->forOutput());
        }
        const C2NumbersStreamTuning *S3[] = { bouts1.get() };
        for (const auto p : S3) {
            EXPECT_FALSE((bool)(*p));
            EXPECT_TRUE(!(*p));

            EXPECT_FALSE(p->forInput());
            EXPECT_FALSE(p->forOutput());
            EXPECT_EQ(0, p->m.mNumbers[0]);
        }

        // values
        EXPECT_EQ(100, ins2->m.mNumbers[0]);
        EXPECT_EQ(100, outs2->m.mNumbers[0]);
        EXPECT_EQ(0, bins1->m.mNumbers[0]);
        EXPECT_EQ(0, bins2->m.mNumbers[0]);
        EXPECT_EQ(0, bouts1->m.mNumbers[0]);
        EXPECT_EQ(0, bouts2->m.mNumbers[0]);

        EXPECT_EQ(1u, ins2->stream());
        EXPECT_EQ(1u, outs2->stream());
        EXPECT_EQ(0u, bins1->stream());
        EXPECT_EQ(0u, bins2->stream());
        EXPECT_EQ(0u, bouts1->stream());
        EXPECT_EQ(0u, bouts2->stream());

        EXPECT_TRUE(*ins1 != *outs1);
        EXPECT_TRUE(*ins1 == *ins2);
        EXPECT_TRUE(*outs1 == *outs2);
        EXPECT_TRUE(*bins1 == *bouts1);
        EXPECT_TRUE(*bins2 != *bouts2);

        EXPECT_TRUE(*ins1 != *bins1);
        bins1->m.mNumbers[0] = 100;
        EXPECT_TRUE(*ins1 != *bins1);
        bins1->setPort(false /* output */);
        EXPECT_TRUE(*ins1 != *bins1);
        bins1->setStream(1u);
        EXPECT_TRUE(*ins1 == *bins1);

        EXPECT_TRUE(*ins2 != *bins2);
        bins2->m.mNumbers[0] = 100;
        EXPECT_TRUE(*ins2 != *bins2);
        bins2->setStream(1u);
        EXPECT_TRUE(*ins2 == *bins2);

        bins1->setPort(true /* output */);
        EXPECT_TRUE(*outs1 == *bins1);

        EXPECT_TRUE(*outs1 != *bouts1);
        bouts1->m.mNumbers[0] = 100;
        EXPECT_TRUE(*outs1 != *bouts1);
        bouts1->setPort(true /* output */);
        EXPECT_TRUE(*outs1 != *bouts1);
        bouts1->setStream(1u);
        EXPECT_TRUE(*outs1 == *bouts1);

        EXPECT_TRUE(*outs2 != *bouts2);
        bouts2->m.mNumbers[0] = 100;
        EXPECT_TRUE(*outs2 != *bouts2);
        bouts2->setStream(1u);
        EXPECT_TRUE(*outs2 == *bouts2);

        bouts1->setPort(false /* output */);
        EXPECT_TRUE(*ins1 == *bouts1);

        // index
        EXPECT_EQ(C2Param::Type(ins1->type()).coreIndex(), C2NumbersStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(ins1->type()).typeIndex(), kParamIndexNumbers);
        EXPECT_EQ(ins1->type(), C2NumbersStreamTuning::input::PARAM_TYPE);

        EXPECT_EQ(C2Param::Type(ins2->type()).coreIndex(), C2NumbersStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(ins2->type()).typeIndex(), kParamIndexNumbers);
        EXPECT_EQ(ins2->type(), C2NumbersStreamTuning::input::PARAM_TYPE);

        EXPECT_EQ(C2Param::Type(outs1->type()).coreIndex(), C2NumbersStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(outs1->type()).typeIndex(), kParamIndexNumbers);
        EXPECT_EQ(outs1->type(), C2NumbersStreamTuning::output::PARAM_TYPE);

        EXPECT_EQ(C2Param::Type(outs2->type()).coreIndex(), C2NumbersStruct::CORE_INDEX);
        EXPECT_EQ(C2Param::Type(outs2->type()).typeIndex(), kParamIndexNumbers);
        EXPECT_EQ(outs2->type(), C2NumbersStreamTuning::output::PARAM_TYPE);

        C2Param::CoreIndex index = C2NumbersStreamTuning::input::PARAM_TYPE;
        EXPECT_FALSE(index.isVendor());
        EXPECT_TRUE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumbers | C2Param::CoreIndex::IS_FLEX_FLAG);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumbers);

        index = C2NumbersStreamTuning::output::PARAM_TYPE;
        EXPECT_FALSE(index.isVendor());
        EXPECT_TRUE(index.isFlexible());
        EXPECT_EQ(index.coreIndex(), kParamIndexNumbers | C2Param::CoreIndex::IS_FLEX_FLAG);
        EXPECT_EQ(index.typeIndex(), kParamIndexNumbers);

        C2Param::Type type = C2NumbersStreamTuning::input::PARAM_TYPE;
        EXPECT_FALSE(type.isVendor());
        EXPECT_TRUE(type.isFlexible());
        EXPECT_FALSE(type.isGlobal());
        EXPECT_TRUE(type.forInput());
        EXPECT_FALSE(type.forOutput());
        EXPECT_TRUE(type.forStream());
        EXPECT_FALSE(type.forPort());

        type = C2NumbersStreamTuning::output::PARAM_TYPE;
        EXPECT_FALSE(type.isVendor());
        EXPECT_TRUE(type.isFlexible());
        EXPECT_FALSE(type.isGlobal());
        EXPECT_FALSE(type.forInput());
        EXPECT_TRUE(type.forOutput());
        EXPECT_TRUE(type.forStream());
        EXPECT_FALSE(type.forPort());

        EXPECT_EQ(C2NumbersPortTuning::From(nullptr), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::input::From(nullptr), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::output::From(nullptr), nullptr);
        EXPECT_EQ(C2NumbersTuning::From(ins1.get()), nullptr);
        EXPECT_EQ(C2NumbersTuning::From(ins2.get()), nullptr);
        EXPECT_EQ(C2NumbersTuning::From(outs1.get()), nullptr);
        EXPECT_EQ(C2NumbersTuning::From(outs2.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::From(ins1.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::From(ins2.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::From(outs1.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::From(outs2.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::input::From(ins1.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::input::From(ins2.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::input::From(outs1.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::input::From(outs2.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::output::From(ins1.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::output::From(ins2.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::output::From(outs1.get()), nullptr);
        EXPECT_EQ(C2NumbersPortTuning::output::From(outs2.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::From(ins1.get()), ins1.get());
        EXPECT_EQ(C2NumbersStreamTuning::From(ins2.get()), (C2NumbersStreamTuning*)ins2.get());
        EXPECT_EQ(C2NumbersStreamTuning::From(outs1.get()), outs1.get());
        EXPECT_EQ(C2NumbersStreamTuning::From(outs2.get()), (C2NumbersStreamTuning*)outs2.get());
        EXPECT_EQ(C2NumbersStreamTuning::input::From(ins1.get()), (C2NumbersStreamTuning::input*)ins1.get());
        EXPECT_EQ(C2NumbersStreamTuning::input::From(ins2.get()), ins2.get());
        EXPECT_EQ(C2NumbersStreamTuning::input::From(outs1.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::input::From(outs2.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::output::From(ins1.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::output::From(ins2.get()), nullptr);
        EXPECT_EQ(C2NumbersStreamTuning::output::From(outs1.get()), (C2NumbersStreamTuning::output*)outs1.get());
        EXPECT_EQ(C2NumbersStreamTuning::output::From(outs2.get()), outs2.get());

        EXPECT_EQ(*(C2Param::Copy(*ins1)), *ins1);
        EXPECT_EQ(*(C2Param::Copy(*ins2)), *ins2);
        EXPECT_EQ(*(C2Param::Copy(*outs1)), *outs1);
        EXPECT_EQ(*(C2Param::Copy(*outs2)), *outs2);
    }

    {
        C2Int32Value int32Value(INT32_MIN);
        static_assert(std::is_same<decltype(int32Value.value), int32_t>::value, "should be int32_t");
        EXPECT_EQ(INT32_MIN, int32Value.value);
        std::vector<C2FieldDescriptor> fields = int32Value.FieldList();
        EXPECT_EQ(1u, fields.size());
        EXPECT_EQ(FD::INT32, fields.cbegin()->type());
        EXPECT_EQ(1u, fields.cbegin()->extent());
        EXPECT_EQ(C2String("value"), fields.cbegin()->name());
    }

    {
        C2Uint32Value uint32Value(UINT32_MAX);
        static_assert(std::is_same<decltype(uint32Value.value), uint32_t>::value, "should be uint32_t");
        EXPECT_EQ(UINT32_MAX, uint32Value.value);
        std::vector<C2FieldDescriptor> fields = uint32Value.FieldList();
        EXPECT_EQ(1u, fields.size());
        EXPECT_EQ(FD::UINT32, fields.cbegin()->type());
        EXPECT_EQ(1u, fields.cbegin()->extent());
        EXPECT_EQ(C2String("value"), fields.cbegin()->name());
    }

    {
        C2Int64Value int64Value(INT64_MIN);
        static_assert(std::is_same<decltype(int64Value.value), int64_t>::value, "should be int64_t");
        EXPECT_EQ(INT64_MIN, int64Value.value);
        std::vector<C2FieldDescriptor> fields = int64Value.FieldList();
        EXPECT_EQ(1u, fields.size());
        EXPECT_EQ(FD::INT64, fields.cbegin()->type());
        EXPECT_EQ(1u, fields.cbegin()->extent());
        EXPECT_EQ(C2String("value"), fields.cbegin()->name());
    }

    {
        C2Uint64Value uint64Value(UINT64_MAX);
        static_assert(std::is_same<decltype(uint64Value.value), uint64_t>::value, "should be uint64_t");
        EXPECT_EQ(UINT64_MAX, uint64Value.value);
        std::vector<C2FieldDescriptor> fields = uint64Value.FieldList();
        EXPECT_EQ(1u, fields.size());
        EXPECT_EQ(FD::UINT64, fields.cbegin()->type());
        EXPECT_EQ(1u, fields.cbegin()->extent());
        EXPECT_EQ(C2String("value"), fields.cbegin()->name());
    }

    {
        C2FloatValue floatValue(123.4f);
        static_assert(std::is_same<decltype(floatValue.value), float>::value, "should be float");
        EXPECT_EQ(123.4f, floatValue.value);
        std::vector<C2FieldDescriptor> fields = floatValue.FieldList();
        EXPECT_EQ(1u, fields.size());
        EXPECT_EQ(FD::FLOAT, fields.cbegin()->type());
        EXPECT_EQ(1u, fields.cbegin()->extent());
        EXPECT_EQ(C2String("value"), fields.cbegin()->name());
    }

    {
        uint8_t initValue[] = "ABCD";
        typedef C2GlobalParam<C2Setting, C2BlobValue, 0> BlobSetting;
        std::unique_ptr<BlobSetting> blobValue = BlobSetting::AllocUnique(6, C2ConstMemoryBlock<uint8_t>(initValue));
        static_assert(std::is_same<decltype(blobValue->m.value), uint8_t[]>::value, "should be uint8_t[]");
        EXPECT_EQ(0, memcmp(blobValue->m.value, "ABCD\0", 6));
        EXPECT_EQ(6u, blobValue->flexCount());
        std::vector<C2FieldDescriptor> fields = blobValue->FieldList();
        EXPECT_EQ(1u, fields.size());
        EXPECT_EQ(FD::BLOB, fields.cbegin()->type());
        EXPECT_EQ(0u, fields.cbegin()->extent());
        EXPECT_EQ(C2String("value"), fields.cbegin()->name());

        blobValue = BlobSetting::AllocUnique(3, C2ConstMemoryBlock<uint8_t>(initValue));
        EXPECT_EQ(0, memcmp(blobValue->m.value, "ABC", 3));
        EXPECT_EQ(3u, blobValue->flexCount());
    }

    {
        constexpr char initValue[] = "ABCD";
        typedef C2GlobalParam<C2Setting, C2StringValue, 0> StringSetting;
        std::unique_ptr<StringSetting> stringValue = StringSetting::AllocUnique(6, C2ConstMemoryBlock<char>(initValue));
        stringValue = StringSetting::AllocUnique(6, initValue);
        static_assert(std::is_same<decltype(stringValue->m.value), char[]>::value, "should be char[]");
        EXPECT_EQ(0, memcmp(stringValue->m.value, "ABCD\0", 6));
        EXPECT_EQ(6u, stringValue->flexCount());
        std::vector<C2FieldDescriptor> fields = stringValue->FieldList();
        EXPECT_EQ(1u, fields.size());
        EXPECT_EQ(FD::STRING, fields.cbegin()->type());
        EXPECT_EQ(0u, fields.cbegin()->extent());
        EXPECT_EQ(C2String("value"), fields.cbegin()->name());

        stringValue = StringSetting::AllocUnique(3, C2ConstMemoryBlock<char>(initValue));
        EXPECT_EQ(0, memcmp(stringValue->m.value, "AB", 3));
        EXPECT_EQ(3u, stringValue->flexCount());

        stringValue = StringSetting::AllocUnique(11, "initValue");
        EXPECT_EQ(0, memcmp(stringValue->m.value, "initValue\0", 11));
        EXPECT_EQ(11u, stringValue->flexCount());

        stringValue = StringSetting::AllocUnique(initValue);
        EXPECT_EQ(0, memcmp(stringValue->m.value, "ABCD", 5));
        EXPECT_EQ(5u, stringValue->flexCount());

        stringValue = StringSetting::AllocUnique({ 'A', 'B', 'C', 'D' });
        EXPECT_EQ(0, memcmp(stringValue->m.value, "ABC", 4));
        EXPECT_EQ(4u, stringValue->flexCount());
    }

    {
        uint32_t videoWidth[] = { 12u, C2NumbersStreamTuning::output::PARAM_TYPE, 100 };
        C2Param *p1 = C2Param::From(videoWidth, sizeof(videoWidth));
        EXPECT_NE(nullptr, p1);
        EXPECT_EQ(12u, p1->size());
        EXPECT_EQ(p1->type(), C2NumbersStreamTuning::output::PARAM_TYPE);

        C2NumbersStreamTuning::output *vst = C2NumbersStreamTuning::output::From(p1);
        EXPECT_NE(nullptr, vst);
        if (vst) {
            EXPECT_EQ(1u, vst->flexCount());
            EXPECT_EQ(100, vst->m.mNumbers[0]);
        }

        p1 = C2Param::From(videoWidth, sizeof(videoWidth) + 2);
        EXPECT_EQ(nullptr, p1);

        p1 = C2Param::From(videoWidth, sizeof(videoWidth) - 2);
        EXPECT_EQ(nullptr, p1);

        p1 = C2Param::From(videoWidth, 3);
        EXPECT_EQ(nullptr, p1);

        p1 = C2Param::From(videoWidth, 0);
        EXPECT_EQ(nullptr, p1);
    }

    {
        uint32_t videoWidth[] = { 16u, C2NumbersPortTuning::input::PARAM_TYPE, 101, 102 };

        C2Param *p1 = C2Param::From(videoWidth, sizeof(videoWidth));
        EXPECT_NE(nullptr, p1);
        EXPECT_EQ(16u, p1->size());
        EXPECT_EQ(p1->type(), C2NumbersPortTuning::input::PARAM_TYPE);

        C2NumbersPortTuning::input *vpt = C2NumbersPortTuning::input::From(p1);
        EXPECT_NE(nullptr, vpt);
        if (vpt) {
            EXPECT_EQ(2u, vpt->flexCount());
            EXPECT_EQ(101, vpt->m.mNumbers[0]);
            EXPECT_EQ(102, vpt->m.mNumbers[1]);
        }

        p1 = C2Param::From(videoWidth, sizeof(videoWidth) + 2);
        EXPECT_EQ(nullptr, p1);

        p1 = C2Param::From(videoWidth, sizeof(videoWidth) - 2);
        EXPECT_EQ(nullptr, p1);

        p1 = C2Param::From(videoWidth, 3);
        EXPECT_EQ(nullptr, p1);

        p1 = C2Param::From(videoWidth, 0);
        EXPECT_EQ(nullptr, p1);
    }
}

TEST_F(C2ParamTest, C2ValueTest) {
    C2Value val;
    int32_t i32 = -32;
    int64_t i64 = -64;
    uint32_t u32 = 32;
    uint64_t u64 = 64;
    float fp = 1.5f;

    EXPECT_EQ(C2Value::NO_INIT, val.type());
    EXPECT_EQ(false, val.get(&i32));
    EXPECT_EQ(-32, i32);
    EXPECT_EQ(false, val.get(&i64));
    EXPECT_EQ(-64, i64);
    EXPECT_EQ(false, val.get(&u32));
    EXPECT_EQ(32u, u32);
    EXPECT_EQ(false, val.get(&u64));
    EXPECT_EQ(64u, u64);
    EXPECT_EQ(false, val.get(&fp));
    EXPECT_EQ(1.5f, fp);

    val = int32_t(-3216);
    EXPECT_EQ(C2Value::INT32, val.type());
    EXPECT_EQ(true, val.get(&i32));
    EXPECT_EQ(-3216, i32);
    EXPECT_EQ(false, val.get(&i64));
    EXPECT_EQ(-64, i64);
    EXPECT_EQ(false, val.get(&u32));
    EXPECT_EQ(32u, u32);
    EXPECT_EQ(false, val.get(&u64));
    EXPECT_EQ(64u, u64);
    EXPECT_EQ(false, val.get(&fp));
    EXPECT_EQ(1.5f, fp);

    val = uint32_t(3216);
    EXPECT_EQ(C2Value::UINT32, val.type());
    EXPECT_EQ(false, val.get(&i32));
    EXPECT_EQ(-3216, i32);
    EXPECT_EQ(false, val.get(&i64));
    EXPECT_EQ(-64, i64);
    EXPECT_EQ(true, val.get(&u32));
    EXPECT_EQ(3216u, u32);
    EXPECT_EQ(false, val.get(&u64));
    EXPECT_EQ(64u, u64);
    EXPECT_EQ(false, val.get(&fp));
    EXPECT_EQ(1.5f, fp);

    val = int64_t(-6432);
    EXPECT_EQ(C2Value::INT64, val.type());
    EXPECT_EQ(false, val.get(&i32));
    EXPECT_EQ(-3216, i32);
    EXPECT_EQ(true, val.get(&i64));
    EXPECT_EQ(-6432, i64);
    EXPECT_EQ(false, val.get(&u32));
    EXPECT_EQ(3216u, u32);
    EXPECT_EQ(false, val.get(&u64));
    EXPECT_EQ(64u, u64);
    EXPECT_EQ(false, val.get(&fp));
    EXPECT_EQ(1.5f, fp);

    val = uint64_t(6432);
    EXPECT_EQ(C2Value::UINT64, val.type());
    EXPECT_EQ(false, val.get(&i32));
    EXPECT_EQ(-3216, i32);
    EXPECT_EQ(false, val.get(&i64));
    EXPECT_EQ(-6432, i64);
    EXPECT_EQ(false, val.get(&u32));
    EXPECT_EQ(3216u, u32);
    EXPECT_EQ(true, val.get(&u64));
    EXPECT_EQ(6432u, u64);
    EXPECT_EQ(false, val.get(&fp));
    EXPECT_EQ(1.5f, fp);

    val = 15.25f;
    EXPECT_EQ(C2Value::FLOAT, val.type());
    EXPECT_EQ(false, val.get(&i32));
    EXPECT_EQ(-3216, i32);
    EXPECT_EQ(false, val.get(&i64));
    EXPECT_EQ(-6432, i64);
    EXPECT_EQ(false, val.get(&u32));
    EXPECT_EQ(3216u, u32);
    EXPECT_EQ(false, val.get(&u64));
    EXPECT_EQ(6432u, u64);
    EXPECT_EQ(true, val.get(&fp));
    EXPECT_EQ(15.25f, fp);
}