External/yaml-cpp
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update the ConvertStreamTo() function and test case

Browse Source
This commit is contained in:
dota17 2020-05-22 15:21:25 +08:00
parent 27d88f83d9
commit ba06ac4986
2 changed files with 33 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
include/yaml-cpp/node/convert.h
View File

@ -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);
return true;
}
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 {
if (num >= std::numeric_limits<T>::min() &&
num <= std::numeric_limits<T>::max()) {
rhs = num;
return true;
}
return true;
}
return false;
}

55
test/integration/load_node_test.cpp
View File

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