TEST(Double, TestParsingOverflow) {
double d;
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("1e309", &d));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-1e309", &d));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("1e-400", &d));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-1e-400", &d));
}
TEST(Double, TestParsingInfinity) {
double d = 0;
ASSERT_OK(parseNumberFromString("infinity", &d));
ASSERT_TRUE(std::isinf(d));
d = 0;
ASSERT_OK(parseNumberFromString("-Infinity", &d));
ASSERT_TRUE(std::isinf(d));
}
float SVGAnimatedNumberAnimator::calculateDistance(const String& fromString, const String& toString)
{
ASSERT(m_contextElement);
float from = 0;
float to = 0;
parseNumberFromString(fromString, from);
parseNumberFromString(toString, to);
return fabsf(to - from);
}
TEST(ParseNumber, UInt8) {
uint8_t ignored;
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-129", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-130", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-900", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("+256", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("+900", &ignored));
for (uint32_t i = 0; i <= 255; ++i)
ASSERT_PARSES(uint8_t, std::string(str::stream() << i), i);
}
static void TestParsingNegatives() {
if (Limits::is_signed) {
ASSERT_PARSES(NumberType, "-0", 0);
ASSERT_PARSES(NumberType, "-10", -10);
ASSERT_PARSES(NumberType, "-0xff", -0xff);
ASSERT_PARSES(NumberType, "-077", -077);
} else {
NumberType ignored;
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-0xff", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-077", &ignored));
}
}
Status ExportedServerParameter<T>::setFromString( const string& str ) {
T value;
Status status = parseNumberFromString( str, &value );
if ( !status.isOK() )
return status;
return set( value );
}
TEST(ParseNumber, TestParsingOverflow) {
uint64_t u64;
// These both have one too many hex digits and will overflow the multiply. The second overflows
// such that the truncated result is still greater than either input and can catch overly
// simplistic overflow checks.
ASSERT_EQUALS(ErrorCodes::FailedToParse,
parseNumberFromStringWithBase("0xfffffffffffffffff", 16, &u64));
ASSERT_EQUALS(ErrorCodes::FailedToParse,
parseNumberFromStringWithBase("0x7ffffffffffffffff", 16, &u64));
// 2**64 exactly. This will overflow the add.
ASSERT_EQUALS(ErrorCodes::FailedToParse,
parseNumberFromStringWithBase("18446744073709551616", 10, &u64));
uint32_t u32;
// Too large when down-converting.
ASSERT_EQUALS(ErrorCodes::FailedToParse,
parseNumberFromStringWithBase("0xfffffffff", 16, &u32));
int32_t i32;
// Too large when down-converting.
ASSERT_EQUALS(
ErrorCodes::FailedToParse,
parseNumberFromString(std::to_string(std::numeric_limits<uint32_t>::max()), &i32));
}
PassOwnPtr<SVGAnimatedType> SVGAnimatedNumberAnimator::constructFromString(const String& string)
{
OwnPtr<SVGAnimatedType> animtedType = SVGAnimatedType::createNumber(new float);
float& animatedNumber = animtedType->number();
if (!parseNumberFromString(string, animatedNumber))
animatedNumber = 0;
return animtedType.release();
}
std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberAnimator::constructFromString(const String& string)
{
auto animatedType = SVGAnimatedType::createNumber(std::make_unique<float>());
float& animatedNumber = animatedType->number();
if (!parseNumberFromString(string, animatedNumber))
animatedNumber = 0;
return animatedType;
}
Status SpecializedWithAtomicValueServerParameter::setFromString(const std::string& value) {
std::uint32_t val;
auto status = parseNumberFromString(value, &val);
if (!status.isOK()) {
return status;
}
_data.store(val);
return Status::OK();
}
// See unit test for example outputs
BSONArray toVersionArray(const char* version){
// this is inefficient, but cached so it doesn't matter
BSONArrayBuilder b;
string curPart;
const char* c = version;
int finalPart = 0; // 0 = final release, -100 = pre, -10 to -1 = -10 + X for rcX
do { //walks versionString including NUL byte
if (!(*c == '.' || *c == '-' || *c == '\0')){
curPart += *c;
continue;
}
int num;
if ( parseNumberFromString( curPart, &num ).isOK() ) {
b.append(num);
}
else if (curPart.empty()){
verify(*c == '\0');
break;
}
else if (startsWith(curPart, "rc")){
num = 0;
verify( parseNumberFromString( curPart.substr(2), &num ).isOK() );
finalPart = -10 + num;
break;
}
else if (curPart == "pre"){
finalPart = -100;
break;
}
curPart = "";
} while (*c++);
b.append(finalPart);
return b.arr();
}
bool SVGAnimatedType::setValueAsString(const QualifiedName& attrName, const String& value)
{
switch (m_type) {
case AnimatedColor:
ASSERT(m_data.color);
*m_data.color = value.isEmpty() ? Color() : SVGColor::colorFromRGBColorString(value);
break;
case AnimatedLength: {
ASSERT(m_data.length);
ExceptionCode ec = 0;
m_data.length->setValueAsString(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName), ec);
return !ec;
}
case AnimatedLengthList:
ASSERT(m_data.lengthList);
m_data.lengthList->parse(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName));
break;
case AnimatedNumber:
ASSERT(m_data.number);
parseNumberFromString(value, *m_data.number);
break;
case AnimatedRect:
ASSERT(m_data.rect);
parseRect(value, *m_data.rect);
break;
case AnimatedString:
ASSERT(m_data.string);
*m_data.string = value;
break;
// These types don't appear in the table in SVGElement::cssPropertyToTypeMap() and thus don't need setValueAsString() support.
case AnimatedAngle:
case AnimatedBoolean:
case AnimatedEnumeration:
case AnimatedInteger:
case AnimatedIntegerOptionalInteger:
case AnimatedNumberList:
case AnimatedNumberOptionalNumber:
case AnimatedPath:
case AnimatedPoints:
case AnimatedPreserveAspectRatio:
case AnimatedTransformList:
case AnimatedUnknown:
// Only SVG DOM animations use these property types - that means setValueAsString() is never used for those.
ASSERT_NOT_REACHED();
break;
}
return true;
}
static void TestParsingLimits() {
NumberType ignored;
ASSERT_PARSES(NumberType, std::string(str::stream() << Limits::max()), Limits::max());
ASSERT_PARSES(NumberType, std::string(str::stream() << Limits::min()), Limits::min());
ASSERT_EQUALS(
ErrorCodes::FailedToParse,
parseNumberFromString(std::string(str::stream() << Limits::max() << '0'), &ignored));
if (Limits::is_signed) {
// Max + 1
ASSERT_EQUALS(
ErrorCodes::FailedToParse,
parseNumberFromString(std::to_string(uint64_t(Limits::max()) + 1), &ignored));
// Min - 1 (equivalent to -(Max + 2))
ASSERT_EQUALS(
ErrorCodes::FailedToParse,
parseNumberFromString("-" + std::to_string(uint64_t(Limits::max()) + 2), &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse,
parseNumberFromString(std::string(str::stream() << Limits::min() << '0'),
&ignored));
}
}
virtual Status setFromString(const std::string& str) {
unsigned newValue;
Status status = parseNumberFromString(str, &newValue);
if (!status.isOK()) {
return status;
}
if (newValue <= 1 || newValue >= 500) {
StringBuilder sb;
sb << "journalCommitInterval must be between 1 and 500, but attempted to set to: "
<< newValue;
return Status(ErrorCodes::BadValue, sb.str());
}
storageGlobalParams.journalCommitInterval = newValue;
return Status::OK();
}
TEST(ParseNumber, Int8) {
int8_t ignored;
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-129", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-130", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-900", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("128", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("130", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("900", &ignored));
for (int32_t i = -128; i <= 127; ++i)
ASSERT_PARSES(int8_t, std::string(str::stream() << i), i);
}
/** transform a BSON array into a vector of BSONElements.
we match array # positions with their vector position, and ignore
any fields with non-numeric field names.
*/
std::vector<BSONElement> BSONElement::Array() const {
chk(mongo::Array);
std::vector<BSONElement> v;
BSONObjIterator i(Obj());
while (i.more()) {
BSONElement e = i.next();
const char* f = e.fieldName();
unsigned u;
Status status = parseNumberFromString(f, &u);
if (status.isOK()) {
verify(u < 1000000);
if (u >= v.size())
v.resize(u + 1);
v[u] = e;
} else {
// ignore?
}
}
return v;
}
TEST(Double, TestParsingNan) {
double d = 0;
ASSERT_OK(parseNumberFromString("NaN", &d));
ASSERT_TRUE(std::isnan(d));
}
TEST(Double, TestParsingNegativeZero) {
double d = 0;
ASSERT_OK(parseNumberFromString("-0.0", &d));
ASSERT_EQ(d, -0.0);
ASSERT_TRUE(std::signbit(d));
}
static void TestParsingGarbage() {
NumberType ignored;
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString(" ", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString(" 10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("15b", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("--10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("+-10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("++10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("--10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("0x+10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("0x-10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("0+10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("0-10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("1+10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("1-10", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("48*3", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("0x", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("+", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("+0x", &ignored));
ASSERT_EQUALS(ErrorCodes::FailedToParse, parseNumberFromString("-0x", &ignored));
}
static float parseNumberFromString(SVGAnimationElement*, const String& string)
{
float number = 0;
parseNumberFromString(string, number);
return number;
}
bool SVGAnimatedType::setValueAsString(const QualifiedName& attrName, const String& value)
{
ExceptionCode ec = 0;
switch (m_type) {
case AnimatedAngle:
ASSERT(m_data.angle);
m_data.angle->setValueAsString(value, ec);
break;
case AnimatedBoolean:
ASSERT(m_data.boolean);
*m_data.boolean = value == "true" ? true : false;
break;
case AnimatedColor:
ASSERT(m_data.color);
*m_data.color = value.isEmpty() ? Color() : SVGColor::colorFromRGBColorString(value);
break;
case AnimatedInteger: {
ASSERT(m_data.integer);
bool ok;
*m_data.integer = value.toIntStrict(&ok);
if (!ok)
ec = 1; // Arbitary value > 0, it doesn't matter as we don't report the exception code.
break;
}
case AnimatedLength:
ASSERT(m_data.length);
m_data.length->setValueAsString(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName), ec);
break;
case AnimatedLengthList:
ASSERT(m_data.lengthList);
m_data.lengthList->parse(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName));
break;
case AnimatedNumber:
ASSERT(m_data.number);
parseNumberFromString(value, *m_data.number);
break;
case AnimatedNumberList:
ASSERT(m_data.numberList);
m_data.numberList->parse(value);
break;
case AnimatedNumberOptionalNumber:
ASSERT(m_data.numberOptionalNumber);
parseNumberOptionalNumber(value, m_data.numberOptionalNumber->first, m_data.numberOptionalNumber->second);
break;
case AnimatedPath: {
ASSERT(m_data.path);
OwnPtr<SVGPathByteStream> pathByteStream = adoptPtr(m_data.path);
if (!SVGPathParserFactory::self()->buildSVGPathByteStreamFromString(value, pathByteStream, UnalteredParsing))
ec = 1; // Arbitary value > 0, it doesn't matter as we don't report the exception code.
m_data.path = pathByteStream.leakPtr();
break;
}
case AnimatedPoints:
ASSERT(m_data.pointList);
m_data.pointList->clear();
pointsListFromSVGData(*m_data.pointList, value);
break;
case AnimatedPreserveAspectRatio:
ASSERT(m_data.preserveAspectRatio);
SVGPreserveAspectRatio::parsePreserveAspectRatio(this, value);
break;
case AnimatedRect:
ASSERT(m_data.rect);
parseRect(value, *m_data.rect);
break;
case AnimatedString:
ASSERT(m_data.string);
*m_data.string = value;
break;
default:
ASSERT_NOT_REACHED();
break;
}
return !ec;
}
Status SpecializedWithCtorAndValueServerParameter::setFromString(const std::string& value) {
return parseNumberFromString(value, &_data);
}
