script_core 0.1.1 → 0.2.4

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

@@ -4,8 +4,13 @@
 #include <vector>
 #include <limits>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #if defined(_MSC_VER) || defined(__MINGW32__)
 #define msgpack_rand() ((double)rand() / RAND_MAX)
 #else  // _MSC_VER || __MINGW32__
@@ -26,7 +31,7 @@ const double kEPS = 1e-10;
         v.push_back(numeric_limits<test_type>::min());                  \
         v.push_back(numeric_limits<test_type>::max());                  \
         for (unsigned int i = 0; i < kLoop; i++)                        \
-            v.push_back(rand());                                        \
+            v.push_back(static_cast<test_type>(rand()));                \
         for (unsigned int i = 0; i < v.size() ; i++) {                  \
             test_type val = v[i];                                       \
             msgpack_sbuffer sbuf;                                       \
@@ -61,7 +66,7 @@ const double kEPS = 1e-10;
         v.push_back(numeric_limits<test_type>::min());                  \
         v.push_back(numeric_limits<test_type>::max());                  \
         for (unsigned int i = 0; i < kLoop; i++)                        \
-            v.push_back(rand());                                        \
+            v.push_back(static_cast<test_type>(rand()));                \
         for (unsigned int i = 0; i < v.size() ; i++) {                  \
             test_type val = v[i];                                       \
             msgpack_sbuffer sbuf;                                       \
@@ -1363,3 +1368,45 @@ 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);
+}

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

@@ -12,8 +12,13 @@
 
 #include "test_allocator.hpp"
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -75,7 +80,7 @@ TEST(MSGPACK_STL, simple_buffer_vector_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         type val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1.push_back(rand());
+            val1.push_back(static_cast<char>(rand()));
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -107,7 +112,7 @@ TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         type val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1.push_back(rand());
+            val1.push_back(static_cast<unsigned char>(rand()));
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -140,7 +145,7 @@ TEST(MSGPACK_STL, simple_buffer_vector_uint8_t)
     for (unsigned int k = 0; k < kLoop; k++) {
         type val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1.push_back(rand());
+            val1.push_back(static_cast<uint8_t>(rand()));
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -528,6 +533,18 @@ TEST(MSGPACK_TUPLE, simple_tuple_less_than_convert)
     EXPECT_EQ(val1.get<1>(), val2.get<1>());
 }
 
+TEST(MSGPACK_TUPLE, simple_tuple_nest)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::type::tuple<msgpack::type::tuple<> > val1;
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    msgpack::type::tuple<msgpack::type::tuple<> > val2;
+    oh.get().convert(val2);
+    EXPECT_EQ(oh.get().via.array.size, 1u);
+}
+
 // TR1
 
 #if defined(MSGPACK_HAS_STD_TR1_UNORDERED_MAP) || defined(MSGPACK_HAS_STD_TR1_UNORDERED_SET)

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

@@ -1,7 +1,12 @@
 #include <msgpack.hpp>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -178,7 +183,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 =
@@ -209,7 +214,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 =
@@ -1044,4 +1049,164 @@ TEST(MSGPACK_CHRONO, system_clock_impl_now)
     EXPECT_EQ(val1, val3);
 }
 
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_zero)
+{
+    std::stringstream ss;
+    timespec val1{ 0, 0 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd6));
+
+    msgpack::object_handle oh;
+    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);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_zero)
+{
+    msgpack::zone z;
+    timespec val1{ 0, 0 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_32bit_sec)
+{
+    std::stringstream ss;
+    timespec val1{ 0xffffffffUL, 0 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd6));
+
+    msgpack::object_handle oh;
+    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);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_32bit_sec)
+{
+    msgpack::zone z;
+    timespec val1{ 0xffffffffUL, 0 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_max_nano)
+{
+    std::stringstream ss;
+    timespec val1{ 0, 999999999 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd7));
+    msgpack::object_handle oh;
+    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);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_max_nano)
+{
+    msgpack::zone z;
+    timespec val1{ 0, 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_34bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    std::stringstream ss;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x3ffffffffULL), 999999999 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd7));
+
+    msgpack::object_handle oh;
+    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);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_34bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    msgpack::zone z;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x3ffffffffULL), 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_35bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    std::stringstream ss;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x7ffffffffULL), 999999999 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xc7));
+
+    msgpack::object_handle oh;
+    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);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_35bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    msgpack::zone z;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x7ffffffffULL), 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_64bit_sec_max_nano)
+{
+    std::stringstream ss;
+    timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::max(), 999999999 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xc7));
+
+    msgpack::object_handle oh;
+    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);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_64bit_sec_max_nano)
+{
+    msgpack::zone z;
+    timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::max(), 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+
 #endif // !defined(MSGPACK_USE_CPP03)

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

@@ -1,7 +1,12 @@
 #include <msgpack.hpp>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -22,8 +27,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_nil)
     std::stringstream ss;
     std::optional<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<int> val2 = oh.get().as<std::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -33,8 +39,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_int)
     std::stringstream ss;
     std::optional<int> val1 = 1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<int> val2 = oh.get().as<std::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -50,8 +57,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector)
     v.push_back(3);
     val1 = v;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     ovi_t  val2 = oh.get().as<ovi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -65,8 +73,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector_optional)
     val1[0] = 1;
     val1[2] = 3;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     voi_t  val2 = oh.get().as<voi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -172,8 +181,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con)
     std::stringstream ss;
     std::optional<no_def_con> val1 = no_def_con(1);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<no_def_con> val2 = oh.get().as<std::optional<no_def_con>>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -190,8 +200,9 @@ TEST(MSGPACK_CPP17, string_view_pack_convert)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     std::string_view val2 = oh.get().as<std::string_view>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -225,7 +236,8 @@ TEST(MSGPACK_CPP17, byte_pack_convert)
     msgpack::pack(ss, val1);
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::byte val2 = oh.get().as<std::byte>();
     EXPECT_EQ(val1, val2);
 }
@@ -258,11 +270,13 @@ TEST(MSGPACK_CPP17, vector_byte_pack_convert)
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(ss.str()[i], packed[i]);
+        std::string const& str = ss.str();
+        EXPECT_EQ(str[i], packed[i]);
     }
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::vector<std::byte> val2 = oh.get().as<std::vector<std::byte>>();
     EXPECT_EQ(val1, val2);
 }
@@ -303,11 +317,13 @@ TEST(MSGPACK_CPP17, carray_byte_pack_convert)
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(ss.str()[i], packed[i]);
+        std::string const& str = ss.str();
+        EXPECT_EQ(str[i], packed[i]);
     }
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::byte val2[sizeof(val1)];
     oh.get().convert(val2);
     for (size_t i = 0; i != sizeof(val1); ++i) {

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

@@ -9,8 +9,13 @@
 #include <list>
 #include <limits>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -26,8 +31,8 @@ const unsigned int kLoop = 1000;
         msgpack::packer<msgpack::sbuffer> pk(sbuf);                     \
         typedef std::vector<test_type> vec_type;                        \
         vec_type vec;                                                   \
-        for(unsigned int i = 0; i < rand() % kLoop; ++i) {              \
-            vec_type::value_type r = rand();                            \
+        for(unsigned int i = 0; i < static_cast<unsigned int>(rand()) % kLoop; ++i) { \
+            vec_type::value_type r = static_cast<test_type>(rand());    \
             vec.push_back(r);                                           \
             pk.pack(r);                                                 \
         }                                                               \
@@ -36,7 +41,7 @@ const unsigned int kLoop = 1000;
         const char *p = sbuf.data();                                    \
         const char * const pend = p + sbuf.size();                      \
         while (p < pend) {                                              \
-            const size_t sz = std::min<size_t>(pend - p, rand() % 128); \
+            const size_t sz = std::min<size_t>(static_cast<std::size_t>(pend - p), static_cast<std::size_t>(rand() % 128)); \
             pac.reserve_buffer(sz);                                     \
             memcpy(pac.buffer(), p, sz);                                \
             pac.buffer_consumed(sz);                                    \