script_core 0.2.1 → 0.2.6

data/ext/enterprise_script_service/msgpack/test/json.cpp

@@ -2,12 +2,16 @@
 #include <fstream>
 #include <sstream>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
+#endif //defined(__GNUC__)
 
 #include <gtest/gtest.h>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic pop
+#endif //defined(__GNUC__)
 
 TEST(json, basic_elements)
 {

data/ext/enterprise_script_service/msgpack/test/limit.cpp

@@ -1,11 +1,15 @@
 #include <msgpack.hpp>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
+#endif //defined(__GNUC__)
 
 #include <gtest/gtest.h>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic pop
+#endif //defined(__GNUC__)
 
 #include <sstream>
 
@@ -525,15 +529,15 @@ TEST(limit, unpack_array_over_off_ref_pointer)
         bool ref;
         std::size_t off = 0;
         msgpack::object_handle unp;
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
         msgpack::unpack(&unp, ss.str().c_str(), ss.str().size(), &off, &ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(2, 0, 0, 0, 0));
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
         EXPECT_TRUE(false);
     }
     catch(msgpack::array_size_overflow const&) {

data/ext/enterprise_script_service/msgpack/test/msgpack_basic.cpp

@@ -9,12 +9,16 @@
 #include <list>
 #include <limits>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
+#endif //defined(__GNUC__)
 
 #include <gtest/gtest.h>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic pop
+#endif //defined(__GNUC__)
 
 #if defined(_MSC_VER) || defined(__MINGW32__)
 #define msgpack_rand() ((double)rand() / RAND_MAX)

data/ext/enterprise_script_service/msgpack/test/msgpack_c.cpp

@@ -4,12 +4,16 @@
 #include <vector>
 #include <limits>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
+#endif //defined(__GNUC__)
 
 #include <gtest/gtest.h>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic pop
+#endif //defined(__GNUC__)
 
 #if defined(_MSC_VER) || defined(__MINGW32__)
 #define msgpack_rand() ((double)rand() / RAND_MAX)
@@ -1368,3 +1372,200 @@ TEST(MSGPACKC, vref_buffer_overflow)
     EXPECT_FALSE(msgpack_vrefbuffer_init(&vbuf, ref_size, chunk_size));
     EXPECT_EQ(-1, msgpack_vrefbuffer_migrate(&vbuf, &to));
 }
+
+TEST(MSGPACKC, object_print_buffer_overflow) {
+  msgpack_object obj;
+  obj.type = MSGPACK_OBJECT_NIL;
+  char buffer[4];
+
+  int ret;
+  ret = msgpack_object_print_buffer(buffer, 1, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 2, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 3, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 4, obj);
+  EXPECT_EQ(3, ret);
+  EXPECT_STREQ("nil", buffer);
+}
+
+TEST(MSGPACKC, object_bin_print_buffer_overflow) {
+  msgpack_object obj;
+  obj.type = MSGPACK_OBJECT_BIN;
+  obj.via.bin.ptr = "test";
+  obj.via.bin.size = 4;
+  char buffer[7];
+
+  int ret;
+  ret = msgpack_object_print_buffer(buffer, 1, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 2, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 3, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 4, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 5, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 6, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 7, obj);
+  EXPECT_EQ(6, ret);
+  EXPECT_STREQ("\"test\"", buffer);
+}
+
+/* test for vrefbuffer */
+#define GEN_TEST_VREFBUFFER_PREPARE(...)                       \
+    msgpack_vrefbuffer vbuf;                                   \
+    msgpack_packer pk;                                         \
+    const iovec *iov;                                          \
+    size_t iovcnt, len = 0, i;                                 \
+    char buf[1024];                                            \
+    msgpack_vrefbuffer_init(&vbuf, 0, 0);                      \
+    msgpack_packer_init(&pk, &vbuf, msgpack_vrefbuffer_write); \
+    __VA_ARGS__;                                               \
+    iov = msgpack_vrefbuffer_vec(&vbuf);                       \
+    iovcnt = msgpack_vrefbuffer_veclen(&vbuf);                 \
+    for (i = 0; i < iovcnt; i++) {                             \
+        memcpy(buf + len, iov[i].iov_base, iov[i].iov_len);    \
+        len += iov[i].iov_len;                                 \
+    }                                                          \
+    msgpack_vrefbuffer_destroy(&vbuf)
+
+#define GEN_TEST_VREFBUFFER_CHECK(...)                \
+    msgpack_object obj;                               \
+    msgpack_unpack_return ret;                        \
+    msgpack_zone z;                                   \
+    msgpack_zone_init(&z, 2048);                      \
+    ret = msgpack_unpack(buf, len, NULL, &z, &obj);   \
+    EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);           \
+    __VA_ARGS__;                                      \
+    msgpack_zone_destroy(&z)
+
+TEST(buffer, vrefbuffer_uint8)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_uint8(&pk, 32));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type);
+        EXPECT_EQ(32U, obj.via.u64));
+}
+
+TEST(buffer, vrefbuffer_int8)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_int8(&pk, -32));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, obj.type);
+        EXPECT_EQ(-32, obj.via.i64));
+}
+
+TEST(buffer, vrefbuffer_float32)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_float(&pk, 1.0));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_FLOAT32, obj.type);
+        EXPECT_EQ(1.0, obj.via.f64));
+}
+
+TEST(buffer, vrefbuffer_float64)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_double(&pk, 1.0));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_FLOAT64, obj.type);
+        EXPECT_EQ(1.0, obj.via.f64));
+}
+
+TEST(buffer, vrefbuffer_nil)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_nil(&pk));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_NIL, obj.type));
+}
+
+TEST(buffer, vrefbuffer_false)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_false(&pk));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type);
+        EXPECT_FALSE(obj.via.boolean));
+}
+
+TEST(buffer, vrefbuffer_true)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_true(&pk));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type);
+        EXPECT_TRUE(obj.via.boolean));
+}
+
+#define TEST_VBUF_RAW_LEN 30U
+char test_vbuf_raw[TEST_VBUF_RAW_LEN] = "frsyuki";
+
+TEST(buffer, vrefbuffer_str)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_str(&pk, TEST_VBUF_RAW_LEN);
+        msgpack_pack_str_body(&pk, test_vbuf_raw, TEST_VBUF_RAW_LEN));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
+        EXPECT_EQ(TEST_VBUF_RAW_LEN, obj.via.str.size);
+        EXPECT_EQ(0, memcmp(test_vbuf_raw, obj.via.str.ptr, 30)));
+}
+
+TEST(buffer, vrefbuffer_bin)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_bin(&pk, TEST_VBUF_RAW_LEN);
+        msgpack_pack_bin_body(&pk, test_vbuf_raw, TEST_VBUF_RAW_LEN));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(TEST_VBUF_RAW_LEN, obj.via.bin.size);
+        EXPECT_EQ(0, memcmp(test_vbuf_raw, obj.via.bin.ptr, TEST_VBUF_RAW_LEN)));
+}
+
+TEST(buffer, vrefbuffer_ext)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_ext(&pk, TEST_VBUF_RAW_LEN, 127);
+        msgpack_pack_ext_body(&pk, test_vbuf_raw, TEST_VBUF_RAW_LEN));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
+        EXPECT_EQ(TEST_VBUF_RAW_LEN, obj.via.ext.size);
+        EXPECT_EQ(0, memcmp(test_vbuf_raw, obj.via.ext.ptr, TEST_VBUF_RAW_LEN)));
+}
+
+TEST(buffer, vrefbuffer_array)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_array(&pk, 2);
+        msgpack_pack_int(&pk, 3);
+        msgpack_pack_int(&pk, 4));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type);
+        EXPECT_EQ(2U, obj.via.array.size);
+        EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.via.array.ptr[0].type);
+        EXPECT_EQ(3U, obj.via.array.ptr[0].via.u64);
+        EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.via.array.ptr[1].type);
+        EXPECT_EQ(4U, obj.via.array.ptr[1].via.u64));
+}
+
+TEST(buffer, vrefbuffer_map)
+{
+    GEN_TEST_VREFBUFFER_PREPARE(
+        msgpack_pack_map(&pk, 1);
+        msgpack_pack_int(&pk, 2);
+        msgpack_pack_int(&pk, 3));
+    GEN_TEST_VREFBUFFER_CHECK(
+        EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type);
+        EXPECT_EQ(1U, obj.via.map.size);
+        EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.via.map.ptr[0].key.type);
+        EXPECT_EQ(2U, obj.via.map.ptr[0].key.via.u64);
+        EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.via.map.ptr[0].val.type);
+        EXPECT_EQ(3U, obj.via.map.ptr[0].val.via.u64));
+}

data/ext/enterprise_script_service/msgpack/test/msgpack_container.cpp

@@ -12,12 +12,16 @@
 
 #include "test_allocator.hpp"
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
+#endif //defined(__GNUC__)
 
 #include <gtest/gtest.h>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic pop
+#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"

data/ext/enterprise_script_service/msgpack/test/msgpack_cpp11.cpp

@@ -1,11 +1,15 @@
 #include <msgpack.hpp>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
+#endif //defined(__GNUC__)
 
 #include <gtest/gtest.h>
 
+#if defined(__GNUC__)
 #pragma GCC diagnostic pop
+#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -183,7 +187,7 @@ TEST(MSGPACK_CPP11, simple_buffer_array_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         array<char, kElements> val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1[i] = rand();
+            val1[i] = static_cast<char>(rand());
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -214,7 +218,7 @@ TEST(MSGPACK_CPP11, simple_buffer_array_unsigned_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         array<unsigned char, kElements> val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1[i] = rand();
+            val1[i] = static_cast<unsigned char>(rand());
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -883,7 +887,7 @@ TEST(MSGPACK_CHRONO, system_clock_32)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
     char packed[] = {
-        static_cast<char>(0xd6),
+        static_cast<char>(0xd6u),
         static_cast<char>(-1),
         static_cast<char>(0x12),
         static_cast<char>(0x34),
@@ -908,12 +912,12 @@ TEST(MSGPACK_CHRONO, system_clock_32_max)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
     char packed[] = {
-        static_cast<char>(0xd6),
+        static_cast<char>(0xd6u),
         static_cast<char>(-1),
-        static_cast<char>(0xff),
-        static_cast<char>(0xff),
-        static_cast<char>(0xff),
-        static_cast<char>(0xff)
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu)
     };
     EXPECT_EQ(memcmp(sbuf.data(), packed, sizeof(packed)), 0);
 
@@ -959,28 +963,28 @@ TEST(MSGPACK_CHRONO, system_clock_64_max)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
     char packed_nano[] = {
-        static_cast<char>(0xd7),
+        static_cast<char>(0xd7u),
         static_cast<char>(-1),
-        static_cast<char>(0xee), // 999,999,999 << 2
+        static_cast<char>(0xeeu), // 999,999,999 << 2
         static_cast<char>(0x6b),
         static_cast<char>(0x27),
-        static_cast<char>(0xfc),
-        static_cast<char>(0xff), // 32 bit sec
-        static_cast<char>(0xff),
-        static_cast<char>(0xff),
-        static_cast<char>(0xff)
+        static_cast<char>(0xfcu),
+        static_cast<char>(0xffu), // 32 bit sec
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu)
     };
     char packed_micro[] = {
-        static_cast<char>(0xd7),
+        static_cast<char>(0xd7u),
         static_cast<char>(-1),
-        static_cast<char>(0xee), // 999,999,000 << 2
+        static_cast<char>(0xeeu), // 999,999,000 << 2
         static_cast<char>(0x6b),
         static_cast<char>(0x18),
         static_cast<char>(0x60),
-        static_cast<char>(0xff), // 32 bit sec
-        static_cast<char>(0xff),
-        static_cast<char>(0xff),
-        static_cast<char>(0xff)
+        static_cast<char>(0xffu), // 32 bit sec
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu)
     };
     if (std::chrono::system_clock::duration::period::ratio::den == 1000000000) {
         EXPECT_EQ(memcmp(sbuf.data(), packed_nano, sizeof(packed_nano)), 0);
@@ -1055,10 +1059,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_zero)
     timespec val1{ 0, 0 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd6));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd6u));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1077,13 +1082,14 @@ TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_zero)
 TEST(MSGPACK_TIMESPEC, timespec_pack_convert_32bit_sec)
 {
     std::stringstream ss;
-    timespec val1{ 0xffffffffUL, 0 };
+    timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::is_signed ? INT32_MAX : UINT32_MAX, 0 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd6));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd6u));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1092,7 +1098,7 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_32bit_sec)
 TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_32bit_sec)
 {
     msgpack::zone z;
-    timespec val1{ 0xffffffffUL, 0 };
+    timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::is_signed ? INT32_MAX : UINT32_MAX, 0 };
     msgpack::object obj(val1, z);
     timespec val2 = obj.as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
@@ -1105,9 +1111,10 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_max_nano)
     timespec val1{ 0, 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd7u));
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1130,10 +1137,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_34bit_sec_max_nano)
     timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x3ffffffffULL), 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd7u));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1157,10 +1165,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_35bit_sec_max_nano)
     timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x7ffffffffULL), 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xc7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xc7u));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1179,14 +1188,16 @@ TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_35bit_sec_max_nano)
 
 TEST(MSGPACK_TIMESPEC, timespec_pack_convert_64bit_sec_max_nano)
 {
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
     std::stringstream ss;
     timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::max(), 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xc7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xc7u));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);