1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
#include "gate/tests.hpp"
#include "gate/strings.hpp"
#include "gate/structs.hpp"

using namespace gate;

struct GATE_CORE_CPP_API TestStruct
{
    gate::int8_t    char_member;
    gate::int16_t   short_member;
    gate::int32_t   int_member;
    gate::int64_t   long_member;
    gate::real32_t  real_member;
    gate::String    string_member;

    TestStruct()
        : char_member(0),
        short_member(0),
        int_member(0),
        long_member(0),
        real_member(0.0f)
    {
    }
};

namespace gate
{
    template<>
    struct StructDescriptor<TestStruct> : public DynStructDescriptorBase<TestStruct>
    {
        StructDescriptor()
            : DynStructDescriptorBase<TestStruct>("TestStruct")
        {
            this->addMember(&TestStruct::char_member, "char_member");
            this->addMember(&TestStruct::short_member, "short_member");
            this->addMember(&TestStruct::int_member, "int_member");
            this->addMember(&TestStruct::long_member, "long_member");
            this->addMember(&TestStruct::real_member, "real_member");
            this->addMember(&TestStruct::string_member, "string_member");
            this->updateDescriptor();
        }
    };
}

template<class T> void check_member(gate::ConstStruct const& s, gate::size_t index, String const& name, T const& expectedValue)
{
    GATEXX_TEST_CHECK(s.getMemberPtr(index) != NULL);
    GATEXX_TEST_CHECK(s.getMemberPtr(name) != NULL);

    T value = T();
    result_t result = s.getMember(index, value);
    GATEXX_TEST_CHECK_OK(result);
    GATEXX_TEST_CHECK_EQUAL(value, expectedValue);

    value = T();
    result = s.getMember(name, value);
    GATEXX_TEST_CHECK_OK(result);
    GATEXX_TEST_CHECK_EQUAL(value, expectedValue);
}

GATEXX_TEST_UNIT(Struct)
{
    gate::Struct<TestStruct> s;
    s.char_member = 1;
    s.short_member = 2000;
    s.int_member = 3000000;
    s.long_member = 4000000000;
    s.real_member = 56.789f;
    s.string_member = "Hello";

    gate::ConstStruct cs(s);

    GATEXX_TEST_CHECK(cs.c_impl() != NULL);
    GATEXX_TEST_CHECK_EQUAL(cs.getMemberCount(), 6U);
    GATEXX_TEST_CHECK_EQUAL(cs.getStructName(), "TestStruct");
    GATEXX_TEST_CHECK_EQUAL(cs.getStructSize(), sizeof(s));
    GATEXX_TEST_CHECK_EQUAL(cs.getMemberIndex("nonsense"), ((gate::size_t)-1));

    GATEXX_TEST_CHECK_EQUAL(cs.getMemberType("short_member"), GATE_TYPE_I16);

    check_member<gate::int8_t>(cs, 0, "char_member", 1);
    check_member<gate::int16_t>(cs, 1, "short_member", 2000);
    check_member<gate::int32_t>(cs, 2, "int_member", 3000000);
    check_member<gate::int64_t>(cs, 3, "long_member", 4000000000);
    check_member<gate::real32_t>(cs, 4, "real_member", 56.789f);
    check_member<gate::String>(cs, 5, "string_member", "Hello");

    gate::ConstStruct cs2 = cs;
    gate::ConstStruct cs3 = cs.c_impl();<--- Variable 'cs3' is reassigned a value before the old one has been used.
    cs3 = cs;<--- Variable 'cs3' is reassigned a value before the old one has been used.

    gate::MutableStruct ms(s);
    GATEXX_TEST_CHECK(ms.c_impl() != NULL);
    GATEXX_TEST_CHECK_EQUAL(ms.getMemberCount(), 6U);
    GATEXX_TEST_CHECK_EQUAL(ms.getStructName(), "TestStruct");
    GATEXX_TEST_CHECK_EQUAL(ms.getStructSize(), sizeof(s));

    gate::int8_t* ptr = static_cast<gate::int8_t*>(ms.getMemberPtr("char_member"));
    GATEXX_TEST_REQUIRE(ptr != NULL);
    *ptr += 5;
    GATEXX_TEST_CHECK_EQUAL(s.char_member, 6);

    gate::MutableStruct ms2(ms);
    gate::MutableStruct ms3(ms.c_impl());
    ms3 = ms2;
}