From a5d7ad3aa8feb08a14b5cca173d673054c1ade23 Mon Sep 17 00:00:00 2001 From: Tom Sepez Date: Thu, 13 Sep 2018 17:41:52 +0000 Subject: Introduce FX_Number class as a replacement for FX_atonum(). The issue with FX_atonum() is that it doesn't return any information about whether it range-checked its integer values as a signed or unsigned type, even though it knows this as part of its processing. Rather than adding another out parameter to that function, create a class to hold all this information together. This is the first place things went astray while diagnosing bug 882959, in that a large positive value was cast to float as a negative value. Unfortunately, this doesn't affect the related bug, but is a step in the right direction. Change-Id: I0977ec8fccf85e2632a962507bdd30a1cbe6d33c Reviewed-on: https://pdfium-review.googlesource.com/42353 Reviewed-by: Lei Zhang Commit-Queue: Tom Sepez --- core/fxcrt/fx_number_unittest.cpp | 165 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 165 insertions(+) create mode 100644 core/fxcrt/fx_number_unittest.cpp (limited to 'core/fxcrt/fx_number_unittest.cpp') diff --git a/core/fxcrt/fx_number_unittest.cpp b/core/fxcrt/fx_number_unittest.cpp new file mode 100644 index 0000000000..83702dadcf --- /dev/null +++ b/core/fxcrt/fx_number_unittest.cpp @@ -0,0 +1,165 @@ +// Copyright 2018 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include + +#include "core/fxcrt/fx_number.h" +#include "testing/gtest/include/gtest/gtest.h" + +TEST(fxnumber, Default) { + FX_Number number; + EXPECT_TRUE(number.IsInteger()); + EXPECT_FALSE(number.IsSigned()); + EXPECT_EQ(0u, number.GetUnsigned()); + EXPECT_EQ(0, number.GetSigned()); + EXPECT_FLOAT_EQ(0.0f, number.GetFloat()); +} + +TEST(fxnumber, FromUnsigned) { + FX_Number number(42u); + EXPECT_TRUE(number.IsInteger()); + EXPECT_FALSE(number.IsSigned()); + EXPECT_EQ(42u, number.GetUnsigned()); + EXPECT_EQ(42, number.GetSigned()); + EXPECT_FLOAT_EQ(42.0f, number.GetFloat()); + + // Show that assignment works. + FX_Number number2 = number; + EXPECT_TRUE(number2.IsInteger()); + EXPECT_FALSE(number2.IsSigned()); + EXPECT_EQ(42u, number2.GetUnsigned()); + EXPECT_EQ(42, number2.GetSigned()); + EXPECT_FLOAT_EQ(42.0F, number2.GetFloat()); +} + +TEST(fxnumber, FromSigned) { + FX_Number number(-128); + EXPECT_TRUE(number.IsInteger()); + EXPECT_TRUE(number.IsSigned()); + EXPECT_EQ(4294967168u, number.GetUnsigned()); + EXPECT_EQ(-128, number.GetSigned()); + EXPECT_FLOAT_EQ(-128.0f, number.GetFloat()); + + // Show that assignment works. + FX_Number number2 = number; + EXPECT_TRUE(number2.IsInteger()); + EXPECT_TRUE(number2.IsSigned()); + EXPECT_EQ(4294967168u, number2.GetUnsigned()); + EXPECT_EQ(-128, number2.GetSigned()); + EXPECT_FLOAT_EQ(-128.0f, number2.GetFloat()); +} + +TEST(fxnumber, FromFloat) { + FX_Number number(-100.001f); + EXPECT_FALSE(number.IsInteger()); + EXPECT_TRUE(number.IsSigned()); + EXPECT_EQ(4294967196u, number.GetUnsigned()); + EXPECT_EQ(-100, number.GetSigned()); + EXPECT_FLOAT_EQ(-100.001f, number.GetFloat()); + + // Show that assignment works. + FX_Number number2 = number; + EXPECT_FALSE(number2.IsInteger()); + EXPECT_TRUE(number2.IsSigned()); + EXPECT_EQ(4294967196u, number2.GetUnsigned()); + EXPECT_EQ(-100, number2.GetSigned()); + EXPECT_FLOAT_EQ(-100.001f, number2.GetFloat()); +} + +TEST(fxnumber, FromStringUnsigned) { + { + FX_Number number(""); + EXPECT_TRUE(number.IsInteger()); + EXPECT_FALSE(number.IsSigned()); + EXPECT_EQ(0u, number.GetUnsigned()); + } + { + FX_Number number("0"); + EXPECT_TRUE(number.IsInteger()); + EXPECT_FALSE(number.IsSigned()); + EXPECT_EQ(0u, number.GetUnsigned()); + } + { + FX_Number number("10"); + EXPECT_TRUE(number.IsInteger()); + EXPECT_FALSE(number.IsSigned()); + EXPECT_EQ(10u, number.GetUnsigned()); + } + { + FX_Number number("4294967295"); + EXPECT_TRUE(number.IsInteger()); + EXPECT_FALSE(number.IsSigned()); + EXPECT_EQ(std::numeric_limits::max(), number.GetUnsigned()); + } + { + // Value overflows. + FX_Number number("4223423494965252"); + EXPECT_TRUE(number.IsInteger()); + EXPECT_FALSE(number.IsSigned()); + EXPECT_EQ(0u, number.GetUnsigned()); + } + { + // No explicit sign will allow the number to go negative if we retrieve + // it as a signed value. This is needed for things like the encryption + // Permissions flag (Table 3.20 PDF 1.7 spec) + FX_Number number("4294965252"); + EXPECT_EQ(-2044, number.GetSigned()); + } +} + +TEST(fxnumber, FromStringSigned) { + { + FX_Number number("-0"); + EXPECT_TRUE(number.IsInteger()); + EXPECT_TRUE(number.IsSigned()); + EXPECT_EQ(0, number.GetSigned()); + } + { + FX_Number number("+0"); + EXPECT_TRUE(number.IsInteger()); + EXPECT_TRUE(number.IsSigned()); + EXPECT_EQ(0, number.GetSigned()); + } + { + FX_Number number("-10"); + EXPECT_TRUE(number.IsInteger()); + EXPECT_TRUE(number.IsSigned()); + EXPECT_EQ(-10, number.GetSigned()); + } + { + FX_Number number("+10"); + EXPECT_TRUE(number.IsInteger()); + EXPECT_TRUE(number.IsSigned()); + EXPECT_EQ(10, number.GetSigned()); + } + { + FX_Number number("-2147483648"); + EXPECT_TRUE(number.IsInteger()); + EXPECT_TRUE(number.IsSigned()); + EXPECT_EQ(std::numeric_limits::min(), number.GetSigned()); + } + { + FX_Number number("+2147483647"); + EXPECT_TRUE(number.IsInteger()); + EXPECT_TRUE(number.IsSigned()); + EXPECT_EQ(std::numeric_limits::max(), number.GetSigned()); + } + { + // Value underflows. + FX_Number number("-2147483649"); + EXPECT_EQ(0u, number.GetUnsigned()); + EXPECT_EQ(0, number.GetSigned()); + } + { + // Value overflows. + FX_Number number("+2147483648"); + EXPECT_EQ(0u, number.GetUnsigned()); + EXPECT_EQ(0, number.GetSigned()); + } +} + +TEST(fxnumber, FromStringFloat) { + FX_Number number("3.24"); + EXPECT_FLOAT_EQ(3.24f, number.GetFloat()); +} -- cgit v1.2.3