update the ConvertStreamTo() function and test case

include/yaml-cpp/node/convert.h

@@ -7,10 +7,8 @@
 #pragma once
 #endif
 
-#include <algorithm>
 #include <array>
 #include <cmath>
-#include <cstdint>
 #include <limits>
 #include <list>
 #include <map>
@@ -117,29 +115,16 @@ inner_encode(const T& rhs, std::stringstream& stream){
 }
 
 template <typename T>
-typename std::enable_if<std::is_same<T, unsigned char>::value, bool>::type
+typename std::enable_if<(std::is_same<T, unsigned char>::value ||
+                         std::is_same<T, signed char>::value), bool>::type
 ConvertStreamTo(std::stringstream& stream, T& rhs) {
-  uint16_t num;
+  int num;
   if ((stream >> std::noskipws >> num) && (stream >> std::ws).eof()) {
-    rhs = std::min(num, (uint16_t)UINT8_MAX);
+    if (num >= std::numeric_limits<T>::min() &&
-    return true;
+        num <= std::numeric_limits<T>::max()) {
-  }
-  return false;
-}
-
-template <typename T>
-typename std::enable_if<std::is_same<T, signed char>::value, bool>::type
-ConvertStreamTo(std::stringstream& stream, T& rhs) {
-  int16_t num;
-  if ((stream >> std::noskipws >> num) && (stream >> std::ws).eof()) {
-    if (num > INT8_MAX) {
-      rhs = INT8_MAX;
-    } else if (num < INT8_MIN) {
-      rhs = INT8_MIN;
-    } else {
       rhs = num;
+      return true;
     }
-    return true;
   }
   return false;
 }

test/integration/load_node_test.cpp

@@ -21,36 +21,35 @@ TEST(LoadNodeTest, FallbackValues) {
 }
 
 TEST(LoadNodeTest, NumericConversion) {
-  Node node = Load("[1.5, 1, .nan, .inf, -.inf, 0x15, 015, -128, 127, 128, 255, 256, a, ab]");
+  EXPECT_EQ(1.5f, Load("1.5").as<float>());
-  EXPECT_EQ(1.5f, node[0].as<float>());
+  EXPECT_EQ(1.5, Load("1.5").as<double>());
-  EXPECT_EQ(1.5, node[0].as<double>());
+  EXPECT_THROW(Load("1.5").as<int>(), TypedBadConversion<int>);
-  EXPECT_THROW(node[0].as<int>(), TypedBadConversion<int>);
+  EXPECT_EQ(1, Load("1").as<int>());
-  EXPECT_EQ(1, node[1].as<int>());
+  EXPECT_EQ(1.0f, Load("1").as<float>());
-  EXPECT_EQ(1.0f, node[1].as<float>());
+  EXPECT_NE(Load(".nan").as<float>(), Load(".nan").as<float>());
-  EXPECT_NE(node[2].as<float>(), node[2].as<float>());
+  EXPECT_EQ(std::numeric_limits<float>::infinity(), Load(".inf").as<float>());
-  EXPECT_EQ(std::numeric_limits<float>::infinity(), node[3].as<float>());
+  EXPECT_EQ(-std::numeric_limits<float>::infinity(), Load("-.inf").as<float>());
-  EXPECT_EQ(-std::numeric_limits<float>::infinity(), node[4].as<float>());
+  EXPECT_EQ(21, Load("0x15").as<int>());
-  EXPECT_EQ(21, node[5].as<int>());
+  EXPECT_EQ(13, Load("015").as<int>());
-  EXPECT_EQ(13, node[6].as<int>());
+  EXPECT_EQ(-128, +Load("-128").as<int8_t>());
-  EXPECT_EQ(-128, +node[7].as<int8_t>());
+  EXPECT_EQ(127, +Load("127").as<int8_t>());
-  EXPECT_EQ(127, +node[8].as<int8_t>());
+  EXPECT_THROW(Load("128").as<int8_t>(), TypedBadConversion<signed char>);
-  EXPECT_EQ(127, +node[9].as<int8_t>());
+  EXPECT_EQ(255, +Load("255").as<uint8_t>());
-  EXPECT_EQ(255, +node[10].as<uint8_t>());
+  EXPECT_THROW(Load("256").as<uint8_t>(), TypedBadConversion<unsigned char>);
-  EXPECT_EQ(255, +node[11].as<uint8_t>());
   // test as<char>/as<uint8_t> with ‘a’,"ab",'1',"127"
-  EXPECT_EQ('a', node[12].as<char>());
+  EXPECT_EQ('a', Load("a").as<char>());
-  EXPECT_THROW(node[13].as<char>(), TypedBadConversion<char>);
+  EXPECT_THROW(Load("ab").as<char>(), TypedBadConversion<char>);
-  EXPECT_EQ('1', node[1].as<char>());
+  EXPECT_EQ('1', Load("1").as<char>());
-  EXPECT_THROW(node[8].as<char>(), TypedBadConversion<char>);
+  EXPECT_THROW(Load("127").as<char>(), TypedBadConversion<char>);
-  EXPECT_THROW(node[12].as<uint8_t>(), TypedBadConversion<unsigned char>);
+  EXPECT_THROW(Load("a").as<uint8_t>(), TypedBadConversion<unsigned char>);
-  EXPECT_THROW(node[13].as<uint8_t>(), TypedBadConversion<unsigned char>);
+  EXPECT_THROW(Load("ab").as<uint8_t>(), TypedBadConversion<unsigned char>);
-  EXPECT_EQ(1, +node[1].as<uint8_t>());
+  EXPECT_EQ(1, +Load("1").as<uint8_t>());
   // Throw exception: convert a negative number to an unsigned number.
-  EXPECT_THROW(node[7].as<unsigned>(), TypedBadConversion<unsigned int>);
+  EXPECT_THROW(Load("-128").as<unsigned>(), TypedBadConversion<unsigned int>);
-  EXPECT_THROW(node[7].as<unsigned short>(), TypedBadConversion<unsigned short>);
+  EXPECT_THROW(Load("-128").as<unsigned short>(), TypedBadConversion<unsigned short>);
-  EXPECT_THROW(node[7].as<unsigned long>(), TypedBadConversion<unsigned long>);
+  EXPECT_THROW(Load("-128").as<unsigned long>(), TypedBadConversion<unsigned long>);
-  EXPECT_THROW(node[7].as<unsigned long long>(), TypedBadConversion<unsigned long long>);
+  EXPECT_THROW(Load("-128").as<unsigned long long>(), TypedBadConversion<unsigned long long>);
-  EXPECT_THROW(node[7].as<uint8_t>(), TypedBadConversion<unsigned char>);
+  EXPECT_THROW(Load("-128").as<uint8_t>(), TypedBadConversion<unsigned char>);
 }
 
 TEST(LoadNodeTest, Binary) {