view release on metacpan or  search on metacpan

msgpack-3.3.0/test/msgpack_x3_parse.cpp  view on Meta::CPAN

}

TEST(MSGPACK_X3_PARSE, map_2)
{
    std::map<int, int> v;
    std::stringstream ss;
    for (int i = 0; i != 0xffU; ++i) v.emplace(i, i);
    msgpack::pack(ss, v);

    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
}

TEST(MSGPACK_X3_PARSE, map_3)
{
    std::map<int, int> v;
    std::stringstream ss;
    for (int i = 0; i != 0xffU+1U; ++i) v.emplace(i, i);
    msgpack::pack(ss, v);

    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
}

TEST(MSGPACK_X3_PARSE, map_4)
{
    std::map<int, int> v;
    std::stringstream ss;
    for (int i = 0; i != 0xffffU; ++i) v.emplace(i, i);
    msgpack::pack(ss, v);

    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
}

TEST(MSGPACK_X3_PARSE, map_5)
{
    std::map<uint32_t, uint32_t> v;
    std::stringstream ss;
    for (uint32_t i = 0; i != 0xffffU+1U; ++i) v.emplace(i, i);
    msgpack::pack(ss, v);

    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
    EXPECT_EQ(v, (oh.get().as<std::map<uint32_t, uint32_t> >()));
}

TEST(MSGPACK_X3_PARSE, float_1)
{
    std::vector<float> v;
    v.push_back(0.0);
    v.push_back(-0.0);
    v.push_back(1.0);
    v.push_back(-1.0);
    v.push_back(numeric_limits<float>::min());
    v.push_back(numeric_limits<float>::max());
    v.push_back(nanf("tag"));
    if (numeric_limits<float>::has_infinity) {
        v.push_back(numeric_limits<float>::infinity());
        v.push_back(-numeric_limits<float>::infinity());
    }
    if (numeric_limits<float>::has_quiet_NaN) {
        v.push_back(numeric_limits<float>::quiet_NaN());
    }
    if (numeric_limits<float>::has_signaling_NaN) {
        v.push_back(numeric_limits<float>::signaling_NaN());
    }

    for (unsigned int i = 0; i < v.size() ; i++) {
        std::stringstream ss;
        float val1 = v[i];
        msgpack::pack(ss, val1);
        msgpack::object_handle oh =
            msgpack::unpack(ss.str().begin(), ss.str().end());
        float val2 = oh.get().as<float>();

        if (std::isnan(val1))
            EXPECT_TRUE(std::isnan(val2));
        else if (std::isinf(val1))
            EXPECT_TRUE(std::isinf(val2));
        else
            EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
    }
}

TEST(MSGPACK_X3_PARSE, double_1)
{
    std::vector<double> v;
    v.push_back(0.0);
    v.push_back(-0.0);
    v.push_back(1.0);
    v.push_back(-1.0);
    v.push_back(numeric_limits<double>::min());
    v.push_back(numeric_limits<double>::max());
    v.push_back(nanf("tag"));
    if (numeric_limits<double>::has_infinity) {
        v.push_back(numeric_limits<double>::infinity());
        v.push_back(-numeric_limits<double>::infinity());
    }
    if (numeric_limits<double>::has_quiet_NaN) {
        v.push_back(numeric_limits<double>::quiet_NaN());
    }
    if (numeric_limits<double>::has_signaling_NaN) {
        v.push_back(numeric_limits<double>::signaling_NaN());
    }

    for (unsigned int i = 0; i < v.size() ; i++) {
        std::stringstream ss;
        double val1 = v[i];
        msgpack::pack(ss, val1);
        msgpack::object_handle oh =
            msgpack::unpack(ss.str().begin(), ss.str().end());
        double val2 = oh.get().as<double>();

        if (std::isnan(val1))
            EXPECT_TRUE(std::isnan(val2));
        else if (std::isinf(val1))
            EXPECT_TRUE(std::isinf(val2));
        else
            EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
    }
}

TEST(MSGPACK_X3_PARSE, string_1)
{
    std::string v;
    std::stringstream ss;
    msgpack::pack(ss, v);

    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
    EXPECT_EQ(v, oh.get().as<std::string>());
}

TEST(MSGPACK_X3_PARSE, string_2)
{
    std::string v;

    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(static_cast<char>('0'+(i%10)));

    std::stringstream ss;
    msgpack::pack(ss, v);

    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
    EXPECT_EQ(v, oh.get().as<std::string>());
}

TEST(MSGPACK_X3_PARSE, string_3)
{
    std::string v;

    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(static_cast<char>('0'+(i%10)));

    std::stringstream ss;
    msgpack::pack(ss, v);

    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
    EXPECT_EQ(v, oh.get().as<std::string>());
}

TEST(MSGPACK_X3_PARSE, string_4)
{
    std::string v;

    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(static_cast<char>('0'+(i%10)));