script_core 0.1.1 → 0.2.4

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

@@ -3,7 +3,14 @@
 #include <msgpack/fbuffer.h>
 #include <msgpack/zbuffer.hpp>
 #include <msgpack/zbuffer.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
+
+#pragma GCC diagnostic pop
+
 #include <string.h>
 
 TEST(buffer, sbuffer)

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

@@ -1,5 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
+
+#pragma GCC diagnostic pop
+
 #include <sstream>
 
 TEST(carray, pack_unpack_int)
@@ -8,7 +15,8 @@ TEST(carray, pack_unpack_int)
     int v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     int v2[2];
@@ -37,7 +45,8 @@ TEST(carray, pack_unpack_const_int)
     const int v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     int v2[2];
@@ -66,7 +75,8 @@ TEST(carray, pack_unpack_string)
     std::string v1[] = { "ABC", "DEFG" };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     std::string v2[2];
@@ -95,7 +105,8 @@ TEST(carray, pack_unpack_char)
     char v1[] = { 0, 1 };
 
     msgpack::pack(ss, msgpack::type::make_array_ref(v1));
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     char v2[2];
@@ -111,7 +122,8 @@ TEST(carray, pack_unpack_char_as_str)
     char v1[2] = { 1, '\0' };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::STR);
     EXPECT_EQ(oh.get().via.str.size, static_cast<size_t>(1));
 
@@ -157,7 +169,8 @@ TEST(carray, pack_unpack_unsigned_char)
     unsigned char v1[] = { 0, 1 };
 
     msgpack::pack(ss, msgpack::type::make_array_ref(v1));
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     unsigned char v2[2];
@@ -173,7 +186,8 @@ TEST(carray, pack_unpack_unsigned_char_as_bin)
     unsigned char v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::BIN);
     EXPECT_EQ(oh.get().via.bin.size, static_cast<size_t>(2));
 
@@ -219,7 +233,8 @@ TEST(carray, pack_unpack_signed_char)
     signed char v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     signed char v2[2];

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

@@ -1,13 +1,19 @@
 #include <msgpack.hpp>
 #include <fstream>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 static void feed_file(msgpack::unpacker& pac, const char* path)
 {
     std::ifstream fin(path);
     while(true) {
         pac.reserve_buffer(32*1024);
-        fin.read(pac.buffer(), pac.buffer_capacity());
+        fin.read(pac.buffer(), static_cast<std::streamsize>(pac.buffer_capacity()));
         if(fin.bad()) {
             throw std::runtime_error("read failed");
         }

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

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 class enum_member {
 public:
     enum_member() : flag(A) { }

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

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 template <typename T>
 void check_size(size_t size) {
     T v(0);
@@ -25,7 +31,7 @@ TEST(fixint, size)
 
 template <typename T>
 void check_convert() {
-    T v1(-11);
+    T v1(typename T::value_type(-11));
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, v1);
 

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

@@ -1,6 +1,12 @@
 #include <msgpack.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 TEST(fixint, size)
 {
     msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
@@ -29,4 +35,3 @@ TEST(fixint, size)
     msgpack_sbuffer_free(sbuf);
     msgpack_packer_free(pk);
 }
-

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

@@ -1,5 +1,10 @@
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #include "../fuzz/unpack_pack_fuzzer.cpp"
 
 TEST(FUZZ_UNPACK_PACK_FUZZER, works)

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

@@ -1,6 +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
@@ -21,7 +27,7 @@ TEST(iterator, vector)
     vec_type vec;
     vec.reserve(VECTOR_SIZE);
     for (unsigned int i = 0; i < VECTOR_SIZE; i++) {
-        vec.push_back(rand());
+        vec.push_back(static_cast<unsigned int>(rand()));
     }
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, vec);
@@ -47,7 +53,7 @@ TEST(iterator, map)
     using map_type = map<unsigned int, unsigned int>;
     map_type map;
     for (unsigned int i = 0; i < MAP_SIZE; i++) {
-        map[rand()] = rand();
+        map[static_cast<unsigned int>(rand())] = static_cast<unsigned int>(rand());
     }
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, map);

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

@@ -1,8 +1,14 @@
 #include <msgpack.hpp>
 #include <fstream>
 #include <sstream>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 TEST(json, basic_elements)
 {
     typedef std::map<std::string, int> map_s_i;

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

@@ -1,5 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
+
+#pragma GCC diagnostic pop
+
 #include <sstream>
 
 TEST(limit, unpack_array_no_over)

data/ext/enterprise_script_service/msgpack/test/msgpack_basic.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
+
 #if defined(_MSC_VER) || defined(__MINGW32__)
 #define msgpack_rand() ((double)rand() / RAND_MAX)
 #else  // _MSC_VER || __MINGW32__
@@ -36,7 +41,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++) {      \
             msgpack::sbuffer sbuf;                          \
             test_type val1 = v[i];                          \
@@ -209,7 +214,7 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
     vector<integer_type> v;
     v.push_back(0);
     v.push_back(1);
-    if (numeric_limits<integer_type>::is_signed) v.push_back(-1);
+    if (numeric_limits<integer_type>::is_signed) v.push_back(static_cast<integer_type>(-1));
     else v.push_back(2);
     for (unsigned int i = 0; i < kLoop; i++) {
         v.push_back(rand() % 0x7FFFFF);
@@ -221,7 +226,7 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         float_type val2 = oh.get().as<float_type>();
-        EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+        EXPECT_TRUE(fabs(val2 - static_cast<float_type>(val1)) <= kEPS);
     }
 }
 
@@ -331,6 +336,16 @@ TEST(MSGPACK, simple_buffer_fixext1)
     EXPECT_EQ(1ul, oh.get().via.ext.size);
     EXPECT_EQ(1, oh.get().via.ext.type());
     EXPECT_EQ(2, oh.get().via.ext.data()[0]);
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(1ul, oh2.get().via.ext.size);
+    EXPECT_EQ(1, oh2.get().via.ext.type());
+    EXPECT_EQ(2, oh2.get().via.ext.data()[0]);
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext2)
@@ -347,6 +362,17 @@ TEST(MSGPACK, simple_buffer_fixext2)
     EXPECT_EQ(0, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(2ul, oh2.get().via.ext.size);
+    EXPECT_EQ(0, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext4)
@@ -363,6 +389,17 @@ TEST(MSGPACK, simple_buffer_fixext4)
     EXPECT_EQ(1, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(4ul, oh2.get().via.ext.size);
+    EXPECT_EQ(1, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext8)
@@ -379,6 +416,17 @@ TEST(MSGPACK, simple_buffer_fixext8)
     EXPECT_EQ(1, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(8ul, oh2.get().via.ext.size);
+    EXPECT_EQ(1, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext16)
@@ -395,6 +443,17 @@ TEST(MSGPACK, simple_buffer_fixext16)
     EXPECT_EQ(1, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(16ul, oh2.get().via.ext.size);
+    EXPECT_EQ(1, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_1byte_0)
@@ -426,6 +485,17 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_255)
     EXPECT_EQ(77, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(size, oh2.get().via.ext.size);
+    EXPECT_EQ(77, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_2byte_256)
@@ -444,6 +514,17 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_256)
     EXPECT_EQ(77, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(size, oh2.get().via.ext.size);
+    EXPECT_EQ(77, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
@@ -462,6 +543,17 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
     EXPECT_EQ(77, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(size, oh2.get().via.ext.size);
+    EXPECT_EQ(77, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
@@ -480,6 +572,17 @@ TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
     EXPECT_EQ(77, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(size, oh2.get().via.ext.size);
+    EXPECT_EQ(77, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_ext_convert)
@@ -566,7 +669,7 @@ TEST(MSGPACK_STL, simple_buffer_string)
     for (unsigned int k = 0; k < kLoop; k++) {
         string val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1 += 'a' + rand() % 26;
+            val1 += static_cast<char>('a' + rand() % 26);
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -583,7 +686,7 @@ TEST(MSGPACK_STL, simple_buffer_cstring)
     for (unsigned int k = 0; k < kLoop; k++) {
         string val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1 += 'a' + rand() % 26;
+            val1 += static_cast<char>('a' + rand() % 26);
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1.c_str());
         msgpack::object_handle oh =
@@ -600,7 +703,7 @@ TEST(MSGPACK_STL, simple_buffer_non_const_cstring)
     for (unsigned int k = 0; k < kLoop; k++) {
         string val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1 += 'a' + rand() % 26;
+            val1 += static_cast<char>('a' + rand() % 26);
         msgpack::sbuffer sbuf;
         char* s = new char[val1.size() + 1];
         std::memcpy(s, val1.c_str(), val1.size() + 1);
@@ -614,3 +717,22 @@ TEST(MSGPACK_STL, simple_buffer_non_const_cstring)
         EXPECT_EQ(val1, val2);
     }
 }
+
+TEST(MSGPACK_STL, simple_buffer_wstring)
+{
+    for (unsigned int k = 0; k < kLoop; k++) {
+        wstring val1;
+        for (unsigned int i = 0; i < kElements; i++)
+            val1 += L'a' + rand() % 26;
+        msgpack::sbuffer sbuf;
+        msgpack::pack(sbuf, val1);
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
+        EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+        wstring val2 = oh.get().as<wstring>();
+        EXPECT_EQ(val1, val2);
+        wstring val3;
+        oh.get().convert(val3);
+        EXPECT_EQ(val1, val3);
+    }
+}