From 260ce4aa1d0b76e311d05500fbceb47006f50da3 Mon Sep 17 00:00:00 2001
From: Takatoshi Kondo <redboltz@gmail.com>
Date: Mon, 20 Jan 2014 09:26:05 +0000
Subject: [PATCH 1/2] Added object that has integer to float and double
 converter.

---
 src/msgpack/type/float.hpp |  28 ++++++++--
 test/msgpack_test.cpp      | 104 +++++++++++++++++++++++++++++++++++++
 2 files changed, 128 insertions(+), 4 deletions(-)

diff --git a/src/msgpack/type/float.hpp b/src/msgpack/type/float.hpp
index 11df6b2c..6ba06d5c 100644
--- a/src/msgpack/type/float.hpp
+++ b/src/msgpack/type/float.hpp
@@ -29,8 +29,18 @@ namespace msgpack {
 
 inline float& operator>> (object o, float& v)
 {
-	if(o.type != type::DOUBLE) { throw type_error(); }
-	v = (float)o.via.dec;
+	if(o.type == type::DOUBLE) {
+		v = (float)o.via.dec;
+	}
+	else if (o.type == type::POSITIVE_INTEGER) {
+		v = (float)o.via.u64;
+	}
+	else if (o.type == type::NEGATIVE_INTEGER) {
+		v = (float)o.via.i64;
+	}
+	else {
+		throw type_error();
+	}
 	return v;
 }
 
@@ -44,8 +54,18 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const float& v)
 
 inline double& operator>> (object o, double& v)
 {
-	if(o.type != type::DOUBLE) { throw type_error(); }
-	v = o.via.dec;
+	if(o.type == type::DOUBLE) {
+		v = o.via.dec;
+	}
+	else if (o.type == type::POSITIVE_INTEGER) {
+		v = (double)o.via.u64;
+	}
+	else if (o.type == type::NEGATIVE_INTEGER) {
+		v = (double)o.via.i64;
+	}
+	else {
+		throw type_error();
+	}
 	return v;
 }
 
diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp
index 5b60dc5b..aee9735e 100644
--- a/test/msgpack_test.cpp
+++ b/test/msgpack_test.cpp
@@ -178,6 +178,110 @@ TEST(MSGPACK, simple_buffer_float)
   }
 }
 
+TEST(MSGPACK, simple_buffer_float_from_signed_long_long)
+{
+  vector<signed long long> v;
+  v.push_back(0);
+  v.push_back(1);
+  v.push_back(-1);
+  v.push_back(numeric_limits<signed long long>::min());
+  v.push_back(numeric_limits<signed long long>::max());
+  for (unsigned int i = 0; i < kLoop; i++) {
+    v.push_back(rand());
+  }
+  for (unsigned int i = 0; i < v.size() ; i++) {
+    msgpack::sbuffer sbuf;
+    signed long long val1 = v[i];
+    msgpack::pack(sbuf, val1);
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret =
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
+    float val2;
+    obj.convert(&val2);
+    EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+  }
+}
+
+TEST(MSGPACK, simple_buffer_float_from_unsigned_long_long)
+{
+  vector<unsigned long long> v;
+  v.push_back(0);
+  v.push_back(1);
+  v.push_back(2);
+  v.push_back(numeric_limits<unsigned long long>::min());
+  v.push_back(numeric_limits<unsigned long long>::max());
+  for (unsigned int i = 0; i < kLoop; i++) {
+    v.push_back(rand());
+  }
+  for (unsigned int i = 0; i < v.size() ; i++) {
+    msgpack::sbuffer sbuf;
+    unsigned long long val1 = v[i];
+    msgpack::pack(sbuf, val1);
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret =
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
+    float val2;
+    obj.convert(&val2);
+    EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+  }
+}
+
+TEST(MSGPACK, simple_buffer_double_from_signed_long_long)
+{
+  vector<signed long long> v;
+  v.push_back(0);
+  v.push_back(1);
+  v.push_back(-1);
+  v.push_back(numeric_limits<signed long long>::min());
+  v.push_back(numeric_limits<signed long long>::max());
+  for (unsigned int i = 0; i < kLoop; i++) {
+    v.push_back(rand());
+  }
+  for (unsigned int i = 0; i < v.size() ; i++) {
+    msgpack::sbuffer sbuf;
+    signed long long val1 = v[i];
+    msgpack::pack(sbuf, val1);
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret =
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
+    double val2;
+    obj.convert(&val2);
+    EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+  }
+}
+
+TEST(MSGPACK, simple_buffer_double_from_unsigned_long_long)
+{
+  vector<unsigned long long> v;
+  v.push_back(0);
+  v.push_back(1);
+  v.push_back(2);
+  v.push_back(numeric_limits<unsigned long long>::min());
+  v.push_back(numeric_limits<unsigned long long>::max());
+  for (unsigned int i = 0; i < kLoop; i++) {
+    v.push_back(rand());
+  }
+  for (unsigned int i = 0; i < v.size() ; i++) {
+    msgpack::sbuffer sbuf;
+    unsigned long long val1 = v[i];
+    msgpack::pack(sbuf, val1);
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret =
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
+    double val2;
+    obj.convert(&val2);
+    EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+  }
+}
+
 TEST(MSGPACK, simple_buffer_double)
 {
   vector<double> v;

From 97a7b7545a529bc29e1cb444b446ccac9883b316 Mon Sep 17 00:00:00 2001
From: Nobuyuki Kubota <nobu.k.jp+github@gmail.com>
Date: Fri, 28 Feb 2014 15:51:41 +0900
Subject: [PATCH 2/2] Refactored test cases with type parameterized test

---
 test/msgpack_test.cpp | 116 ++++++++++++------------------------------
 1 file changed, 33 insertions(+), 83 deletions(-)

diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp
index aee9735e..77e79e08 100644
--- a/test/msgpack_test.cpp
+++ b/test/msgpack_test.cpp
@@ -7,6 +7,7 @@
 #include <deque>
 #include <set>
 #include <list>
+#include <type_traits>
 
 #include <gtest/gtest.h>
 
@@ -178,109 +179,58 @@ TEST(MSGPACK, simple_buffer_float)
   }
 }
 
-TEST(MSGPACK, simple_buffer_float_from_signed_long_long)
+namespace {
+template<typename F, typename I>
+struct TypePair {
+  typedef F float_type;
+  typedef I integer_type;
+};
+} // namespace
+
+template <typename T>
+class IntegerToFloatingPointTest : public testing::Test {
+};
+TYPED_TEST_CASE_P(IntegerToFloatingPointTest);
+
+TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
 {
-  vector<signed long long> v;
+  typedef typename TypeParam::float_type float_type;
+  typedef typename TypeParam::integer_type integer_type;
+  vector<integer_type> v;
   v.push_back(0);
   v.push_back(1);
-  v.push_back(-1);
-  v.push_back(numeric_limits<signed long long>::min());
-  v.push_back(numeric_limits<signed long long>::max());
+  if (is_signed<integer_type>::value) v.push_back(-1);
+  else v.push_back(2);
+  v.push_back(numeric_limits<integer_type>::min());
+  v.push_back(numeric_limits<integer_type>::max());
   for (unsigned int i = 0; i < kLoop; i++) {
     v.push_back(rand());
   }
   for (unsigned int i = 0; i < v.size() ; i++) {
     msgpack::sbuffer sbuf;
-    signed long long val1 = v[i];
+    integer_type val1 = v[i];
     msgpack::pack(sbuf, val1);
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    float val2;
+    float_type val2;
     obj.convert(&val2);
     EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
   }
 }
 
-TEST(MSGPACK, simple_buffer_float_from_unsigned_long_long)
-{
-  vector<unsigned long long> v;
-  v.push_back(0);
-  v.push_back(1);
-  v.push_back(2);
-  v.push_back(numeric_limits<unsigned long long>::min());
-  v.push_back(numeric_limits<unsigned long long>::max());
-  for (unsigned int i = 0; i < kLoop; i++) {
-    v.push_back(rand());
-  }
-  for (unsigned int i = 0; i < v.size() ; i++) {
-    msgpack::sbuffer sbuf;
-    unsigned long long val1 = v[i];
-    msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    float val2;
-    obj.convert(&val2);
-    EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
-  }
-}
+REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest,
+                           simple_buffer);
 
-TEST(MSGPACK, simple_buffer_double_from_signed_long_long)
-{
-  vector<signed long long> v;
-  v.push_back(0);
-  v.push_back(1);
-  v.push_back(-1);
-  v.push_back(numeric_limits<signed long long>::min());
-  v.push_back(numeric_limits<signed long long>::max());
-  for (unsigned int i = 0; i < kLoop; i++) {
-    v.push_back(rand());
-  }
-  for (unsigned int i = 0; i < v.size() ; i++) {
-    msgpack::sbuffer sbuf;
-    signed long long val1 = v[i];
-    msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    double val2;
-    obj.convert(&val2);
-    EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
-  }
-}
-
-TEST(MSGPACK, simple_buffer_double_from_unsigned_long_long)
-{
-  vector<unsigned long long> v;
-  v.push_back(0);
-  v.push_back(1);
-  v.push_back(2);
-  v.push_back(numeric_limits<unsigned long long>::min());
-  v.push_back(numeric_limits<unsigned long long>::max());
-  for (unsigned int i = 0; i < kLoop; i++) {
-    v.push_back(rand());
-  }
-  for (unsigned int i = 0; i < v.size() ; i++) {
-    msgpack::sbuffer sbuf;
-    unsigned long long val1 = v[i];
-    msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    double val2;
-    obj.convert(&val2);
-    EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
-  }
-}
+typedef testing::Types<TypePair<float, signed long long>,
+                       TypePair<float, unsigned long long>,
+                       TypePair<double, signed long long>,
+                       TypePair<double, unsigned long long> > IntegerToFloatingPointTestTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance,
+                              IntegerToFloatingPointTest,
+                              IntegerToFloatingPointTestTypes);
 
 TEST(MSGPACK, simple_buffer_double)
 {