3party/crashpad
0
0
Fork 0
mirror of https://github.com/chromium/crashpad.git synced 2024-12-31 01:43:03 +08:00
Code Issues Projects Releases Wiki Activity
crashpad/util/stdlib/string_number_conversion_test.cc

407 lines
14 KiB
C++
Raw Normal View History

Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
// Copyright 2014 The Crashpad Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "util/stdlib/string_number_conversion.h"
Use base/macros.h instead of base/basictypes.h This was done in Chromium’s local copy of Crashpad in 562827afb599. This change is similar to that one, except more care was taken to avoid including headers from a .cc or _test.cc when already included by the associated .h. Rather than using <stddef.h> for size_t, Crashpad has always used <sys/types.h>, so that’s used here as well. This updates mini_chromium to 8a2363f486e3a0dc562a68884832d06d28d38dcc, which removes base/basictypes.h. e128dcf10122 Remove base/move.h; use std::move() instead of Pass() 8a2363f486e3 Move basictypes.h to macros.h R=avi@chromium.org Review URL: https://codereview.chromium.org/1566713002 .
2016-01-06 12:22:50 -05:00
#include <sys/types.h>
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
#include <array>
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
#include <limits>
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
#include <type_traits>
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
Use base::size where appropriate, and ArraySize elsewhere This is a follow-up to c8a016b99d97, following the post-landing discussion at https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1393921/5#message-2058541d8c4505d20a990ab7734cd758e437a5f7 base::size, and std::size that will eventually replace it when C++17 is assured, does not allow the size of non-static data members to be taken in constant expression context. The remaining uses of ArraySize are in: minidump/minidump_exception_writer.cc (×1) minidump/minidump_system_info_writer.cc (×2, also uses base::size) snapshot/cpu_context.cc (×4, also uses base::size) util/misc/arraysize_test.cc (×10, of course) The first of these occurs when initializing a constexpr variable. All others are in expressions used with static_assert. Includes: Update mini_chromium to 737433ebade4d446643c6c07daae02a67e8deccao f701716d9546 Add Windows ARM64 build target to mini_chromium 87a95a3d6ac2 Remove the arraysize macro 1f7255ead1f7 Placate MSVC in areas of base::size usage 737433ebade4 Add cast Bug: chromium:837308 Change-Id: I6a5162654461b1bdd9b7b6864d0d71a734bcde19 Reviewed-on: https://chromium-review.googlesource.com/c/1396108 Commit-Queue: Mark Mentovai <mark@chromium.org> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-01-04 16:57:57 -05:00
#include "base/stl_util.h"
Use base/macros.h instead of base/basictypes.h This was done in Chromium’s local copy of Crashpad in 562827afb599. This change is similar to that one, except more care was taken to avoid including headers from a .cc or _test.cc when already included by the associated .h. Rather than using <stddef.h> for size_t, Crashpad has always used <sys/types.h>, so that’s used here as well. This updates mini_chromium to 8a2363f486e3a0dc562a68884832d06d28d38dcc, which removes base/basictypes.h. e128dcf10122 Remove base/move.h; use std::move() instead of Pass() 8a2363f486e3 Move basictypes.h to macros.h R=avi@chromium.org Review URL: https://codereview.chromium.org/1566713002 .
2016-01-06 12:22:50 -05:00
#include "gtest/gtest.h"
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
#define STRINGIFY(a) STR(a)
#define STR(a) #a
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
template <typename TValueType>
struct TestSpecification {
const char* string;
bool valid;
TValueType value;
};
// Signed 32-bit test data
template <typename TIntType,
typename std::enable_if<std::is_integral<TIntType>::value &&
std::is_signed<TIntType>::value &&
(sizeof(TIntType) == 4)>::type* = nullptr>
static constexpr std::array<TestSpecification<TIntType>, 61> kTestDataFunc() {
return {{
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
{"", false, 0},
{"0", true, 0},
{"1", true, 1},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"2147483647", true, std::numeric_limits<TIntType>::max()},
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
{"2147483648", false, 0},
{"4294967295", false, 0},
{"4294967296", false, 0},
{"-1", true, -1},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"-2147483648", true, std::numeric_limits<TIntType>::min()},
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
{"-2147483649", false, 0},
{"00", true, 0},
{"01", true, 1},
{"-01", true, -1},
{"+2", true, 2},
{"0x10", true, 16},
{"-0x10", true, -16},
{"+0x20", true, 32},
{"0xf", true, 15},
{"0xg", false, 0},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"0x7fffffff", true, std::numeric_limits<TIntType>::max()},
{"0x7FfFfFfF", true, std::numeric_limits<TIntType>::max()},
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
{"0x80000000", false, 0},
{"0xFFFFFFFF", false, 0},
{"-0x7fffffff", true, -2147483647},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"-0x80000000", true, std::numeric_limits<TIntType>::min()},
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
{"-0x80000001", false, 0},
{"-0xffffffff", false, 0},
{"0x100000000", false, 0},
{"0xabcdef", true, 11259375},
{"010", true, 8},
{"-010", true, -8},
{"+020", true, 16},
{"07", true, 7},
{"08", false, 0},
{" 0", false, 0},
{"0 ", false, 0},
{" 0 ", false, 0},
{" 1", false, 0},
{"1 ", false, 0},
{" 1 ", false, 0},
{"a2", false, 0},
{"2a", false, 0},
{"2a2", false, 0},
{".0", false, 0},
{".1", false, 0},
{"-.2", false, 0},
{"+.3", false, 0},
{"1.23", false, 0},
{"-273.15", false, 0},
{"+98.6", false, 0},
{"1e1", false, 0},
{"1E1", false, 0},
{"0x123p4", false, 0},
{"infinity", false, 0},
{"NaN", false, 0},
{"-9223372036854775810", false, 0},
{"-9223372036854775809", false, 0},
{"9223372036854775808", false, 0},
{"9223372036854775809", false, 0},
{"18446744073709551615", false, 0},
{"18446744073709551616", false, 0},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
}};
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
}
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
// Unsigned 32-bit test data
template <typename TIntType,
typename std::enable_if<std::is_integral<TIntType>::value &&
!std::is_signed<TIntType>::value &&
(sizeof(TIntType) == 4)>::type* = nullptr>
static constexpr std::array<TestSpecification<TIntType>, 61> kTestDataFunc() {
return {{
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
{"", false, 0},
{"0", true, 0},
{"1", true, 1},
{"2147483647", true, 2147483647},
{"2147483648", true, 2147483648},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"4294967295", true, std::numeric_limits<TIntType>::max()},
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
{"4294967296", false, 0},
{"-1", false, 0},
{"-2147483648", false, 0},
{"-2147483649", false, 0},
{"00", true, 0},
{"01", true, 1},
{"-01", false, 0},
{"+2", true, 2},
{"0x10", true, 16},
{"-0x10", false, 0},
{"+0x20", true, 32},
{"0xf", true, 15},
{"0xg", false, 0},
{"0x7fffffff", true, 0x7fffffff},
{"0x7FfFfFfF", true, 0x7fffffff},
{"0x80000000", true, 0x80000000},
{"0xFFFFFFFF", true, 0xffffffff},
{"-0x7fffffff", false, 0},
{"-0x80000000", false, 0},
{"-0x80000001", false, 0},
{"-0xffffffff", false, 0},
{"0x100000000", false, 0},
{"0xabcdef", true, 11259375},
{"010", true, 8},
{"-010", false, 0},
{"+020", true, 16},
{"07", true, 7},
{"08", false, 0},
{" 0", false, 0},
{"0 ", false, 0},
{" 0 ", false, 0},
{" 1", false, 0},
{"1 ", false, 0},
{" 1 ", false, 0},
{"a2", false, 0},
{"2a", false, 0},
{"2a2", false, 0},
{".0", false, 0},
{".1", false, 0},
{"-.2", false, 0},
{"+.3", false, 0},
{"1.23", false, 0},
{"-273.15", false, 0},
{"+98.6", false, 0},
{"1e1", false, 0},
{"1E1", false, 0},
{"0x123p4", false, 0},
{"infinity", false, 0},
{"NaN", false, 0},
{"-9223372036854775810", false, 0},
{"-9223372036854775809", false, 0},
{"9223372036854775808", false, 0},
{"9223372036854775809", false, 0},
{"18446744073709551615", false, 0},
{"18446744073709551616", false, 0},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
}};
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
}
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
// Signed 64-bit test data
template <typename TIntType,
typename std::enable_if<std::is_integral<TIntType>::value &&
std::is_signed<TIntType>::value &&
(sizeof(TIntType) == 8)>::type* = nullptr>
static constexpr std::array<TestSpecification<TIntType>, 24> kTestDataFunc() {
return {{
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
{"", false, 0},
{"0", true, 0},
{"1", true, 1},
{"2147483647", true, 2147483647},
{"2147483648", true, 2147483648},
{"4294967295", true, 4294967295},
{"4294967296", true, 4294967296},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"9223372036854775807", true, std::numeric_limits<TIntType>::max()},
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
{"9223372036854775808", false, 0},
{"18446744073709551615", false, 0},
{"18446744073709551616", false, 0},
{"-1", true, -1},
Fix Windows build after f09d0cde00a1 While building crashpad_database_util.cc: …\crashpad\tools\crashpad_database_util.cc(150) : error C3861: 'gettimeofday': identifier not found util/win/time.h has its own GetTimeOfDay() to provide this missing function on Windows. I don’t know why it’s not in compat. Even so, it doesn’t return a value, so it’d be unsuitable for use in the PCHECK(). Go back to time() with an errno test. While building string_number_conversion_test.cc: …\crashpad\util\stdlib\string_number_conversion_test.cc(242) : error C2220: warning treated as error - no 'object' file generated …\crashpad\util\stdlib\string_number_conversion_test.cc(242) : warning C4146: unary minus operator applied to unsigned type, result still unsigned …\crashpad\util\stdlib\string_number_conversion_test.cc(243) : warning C4146: unary minus operator applied to unsigned type, result still unsigned …\crashpad\util\stdlib\string_number_conversion_test.cc(244) : warning C4146: unary minus operator applied to unsigned type, result still unsigned Use INT64_C(), and remove a duplicate test case. Change-Id: I308db9856e492604c7462238cb8b7b66731f0cfe Reviewed-on: https://chromium-review.googlesource.com/411331 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 14:12:23 -05:00
{"-2147483648", true, INT64_C(-2147483648)},
{"-2147483649", true, INT64_C(-2147483649)},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"-9223372036854775808", true, std::numeric_limits<TIntType>::min()},
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
{"-9223372036854775809", false, 0},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"0x7fffffffffffffff", true, std::numeric_limits<TIntType>::max()},
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
{"0x8000000000000000", false, 0},
{"0xffffffffffffffff", false, 0},
{"0x10000000000000000", false, 0},
{"-0x7fffffffffffffff", true, -9223372036854775807},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"-0x8000000000000000", true, std::numeric_limits<TIntType>::min()},
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
{"-0x8000000000000001", false, 0},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"0x7Fffffffffffffff", true, std::numeric_limits<TIntType>::max()},
}};
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
}
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
// Unsigned 64-bit test data
template <typename TIntType,
typename std::enable_if<std::is_integral<TIntType>::value &&
!std::is_signed<TIntType>::value &&
(sizeof(TIntType) == 8)>::type* = nullptr>
static constexpr std::array<TestSpecification<TIntType>, 25> kTestDataFunc() {
return {{
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
{"", false, 0},
{"0", true, 0},
{"1", true, 1},
{"2147483647", true, 2147483647},
{"2147483648", true, 2147483648},
{"4294967295", true, 4294967295},
{"4294967296", true, 4294967296},
{"9223372036854775807", true, 9223372036854775807},
{"9223372036854775808", true, 9223372036854775808u},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"18446744073709551615", true, std::numeric_limits<TIntType>::max()},
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
{"18446744073709551616", false, 0},
{"-1", false, 0},
{"-2147483648", false, 0},
{"-2147483649", false, 0},
{"-2147483648", false, 0},
{"-9223372036854775808", false, 0},
{"-9223372036854775809", false, 0},
{"0x7fffffffffffffff", true, 9223372036854775807},
{"0x8000000000000000", true, 9223372036854775808u},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"0xffffffffffffffff", true, std::numeric_limits<TIntType>::max()},
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
{"0x10000000000000000", false, 0},
{"-0x7fffffffffffffff", false, 0},
{"-0x8000000000000000", false, 0},
{"-0x8000000000000001", false, 0},
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
{"0xFfffffffffffffff", true, std::numeric_limits<TIntType>::max()},
}};
}
// This string is split to avoid MSVC warning:
// "decimal digit terminates octal escape sequence".
static constexpr char kEmbeddedNullInputRaw[] = "6\000" "6";
namespace crashpad {
namespace test {
namespace {
TEST(StringNumberConversion, StringToInt) {
static_assert(sizeof(int) == 4, "Test only configured for 32-bit int.");
static constexpr auto kTestData = kTestDataFunc<int>();
for (size_t index = 0; index < kTestData.size(); ++index) {
int value;
bool valid = StringToNumber(kTestData[index].string, &value);
if (kTestData[index].valid) {
EXPECT_TRUE(valid) << "index " << index << ", string "
<< kTestData[index].string;
if (valid) {
EXPECT_EQ(value, kTestData[index].value)
<< "index " << index << ", string " << kTestData[index].string;
}
} else {
EXPECT_FALSE(valid) << "index " << index << ", string "
<< kTestData[index].string << ", value " << value;
}
}
// Ensure that embedded NUL characters are treated as bad input. The string
// is split to avoid MSVC warning:
// "decimal digit terminates octal escape sequence".
int output;
std::string kEmbeddedNullInput(kEmbeddedNullInputRaw,
base::size(kEmbeddedNullInputRaw) - 1);
EXPECT_FALSE(StringToNumber(kEmbeddedNullInput, &output));
}
TEST(StringNumberConversion, StringToUnsignedInt) {
static_assert(sizeof(unsigned int) == 4,
"Test only configured for 32-bit unsigned int.");
static constexpr auto kTestData = kTestDataFunc<unsigned int>();
for (size_t index = 0; index < kTestData.size(); ++index) {
unsigned int value;
bool valid = StringToNumber(kTestData[index].string, &value);
if (kTestData[index].valid) {
EXPECT_TRUE(valid) << "index " << index << ", string "
<< kTestData[index].string;
if (valid) {
EXPECT_EQ(value, kTestData[index].value)
<< "index " << index << ", string " << kTestData[index].string;
}
} else {
EXPECT_FALSE(valid) << "index " << index << ", string "
<< kTestData[index].string << ", value " << value;
}
}
// Ensure that embedded NUL characters are treated as bad input. The string
// is split to avoid MSVC warning:
// "decimal digit terminates octal escape sequence".
unsigned int output;
std::string kEmbeddedNullInput(kEmbeddedNullInputRaw,
base::size(kEmbeddedNullInputRaw) - 1);
EXPECT_FALSE(StringToNumber(kEmbeddedNullInput, &output));
}
TEST(StringNumberConversion, StringToLong) {
static_assert(
sizeof(long) == 4 || sizeof(long) == 8,
"Test not configured for " STRINGIFY(__SIZEOF_LONG__) "-byte long");
static constexpr auto kTestData = kTestDataFunc<long>();
for (size_t index = 0; index < kTestData.size(); ++index) {
long value;
bool valid = StringToNumber(kTestData[index].string, &value);
if (kTestData[index].valid) {
EXPECT_TRUE(valid) << "index " << index << ", string "
<< kTestData[index].string;
if (valid) {
EXPECT_EQ(value, kTestData[index].value)
<< "index " << index << ", string " << kTestData[index].string;
}
} else {
EXPECT_FALSE(valid) << "index " << index << ", string "
<< kTestData[index].string << ", value " << value;
}
}
}
TEST(StringNumberConversion, StringToUnsignedLong) {
static_assert(
sizeof(long) == 4 || sizeof(long) == 8,
"Test not configured for " STRINGIFY(__SIZEOF_LONG__) "-byte long");
static constexpr auto kTestData = kTestDataFunc<unsigned long>();
for (size_t index = 0; index < kTestData.size(); ++index) {
unsigned long value;
bool valid = StringToNumber(kTestData[index].string, &value);
if (kTestData[index].valid) {
EXPECT_TRUE(valid) << "index " << index << ", string "
<< kTestData[index].string;
if (valid) {
EXPECT_EQ(value, kTestData[index].value)
<< "index " << index << ", string " << kTestData[index].string;
}
} else {
EXPECT_FALSE(valid) << "index " << index << ", string "
<< kTestData[index].string << ", value " << value;
}
}
}
TEST(StringNumberConversion, StringToLongLong) {
static_assert(sizeof(long long) == 8,
"Test only configured for 64-bit long long.");
static constexpr auto kTestData = kTestDataFunc<long long>();
for (size_t index = 0; index < kTestData.size(); ++index) {
long long value;
bool valid = StringToNumber(kTestData[index].string, &value);
if (kTestData[index].valid) {
EXPECT_TRUE(valid) << "index " << index << ", string "
<< kTestData[index].string;
if (valid) {
EXPECT_EQ(value, kTestData[index].value)
<< "index " << index << ", string " << kTestData[index].string;
}
} else {
EXPECT_FALSE(valid) << "index " << index << ", string "
<< kTestData[index].string << ", value " << value;
}
}
}
TEST(StringNumberConversion, StringToUnsignedLongLong) {
static_assert(sizeof(unsigned long long) == 8,
"Test only configured for 64-bit unsigned long long.");
static constexpr auto kTestData = kTestDataFunc<unsigned long long>();
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
Switch all string-number conversion to use fundamental types, and add long to the list. Change-Id: I9244df09415f9d46262e2b8d04b64d7c4f786436 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565287 Commit-Queue: Eric Astor <epastor@google.com> Reviewed-by: Mark Mentovai <mark@chromium.org>
2019-04-12 13:42:44 -04:00
for (size_t index = 0; index < kTestData.size(); ++index) {
unsigned long long value;
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
bool valid = StringToNumber(kTestData[index].string, &value);
if (kTestData[index].valid) {
EXPECT_TRUE(valid) << "index " << index << ", string "
<< kTestData[index].string;
if (valid) {
test: Use (actual, [un]expected) in gtest {ASSERT,EXPECT}_{EQ,NE} gtest used to require (expected, actual) ordering for arguments to EXPECT_EQ and ASSERT_EQ, and in failed test assertions would identify each side as “expected” or “actual.” Tests in Crashpad adhered to this traditional ordering. After a gtest change in February 2016, it is now agnostic with respect to the order of these arguments. This change mechanically updates all uses of these macros to (actual, expected) by reversing them. This provides consistency with our use of the logging CHECK_EQ and DCHECK_EQ macros, and makes for better readability by ordinary native speakers. The rough (but working!) conversion tool is https://chromium-review.googlesource.com/c/466727/1/rewrite_expectassert_eq.py, and “git cl format” cleaned up its output. EXPECT_NE and ASSERT_NE never had a preferred ordering. gtest never made a judgment that one side or the other needed to provide an “unexpected” value. Consequently, some code used (unexpected, actual) while other code used (actual, unexpected). For consistency with the new EXPECT_EQ and ASSERT_EQ usage, as well as consistency with CHECK_NE and DCHECK_NE, this change also updates these use sites to (actual, unexpected) where one side can be called “unexpected” as, for example, std::string::npos can be. Unfortunately, this portion was a manual conversion. References: https://github.com/google/googletest/blob/master/googletest/docs/Primer.md#binary-comparison https://github.com/google/googletest/commit/77d6b173380332b1c1bc540532641f410ec82d65 https://github.com/google/googletest/pull/713 Change-Id: I978fef7c94183b8b1ef63f12f5ab4d6693626be3 Reviewed-on: https://chromium-review.googlesource.com/466727 Reviewed-by: Scott Graham <scottmg@chromium.org>
2017-04-04 00:35:21 -04:00
EXPECT_EQ(value, kTestData[index].value)
Improve time handling and error checking The database settings object’s last_upload_attempt_time (time_t) field is switched from uint64_t to int64_t, for better compatibility with time_t, which is normally a signed type. This change should be transparent, as there should be no valid high-bit-set 64-bit timestamps in this field in the wild. A number of improvements are made to crashpad_database_util’s time handling. Errors are checked during time conversion. --set-last-upload-attempt-time=now is a new supported (and documented) option. A StringToNumber() overload for int64_t, along with a test, is added to aid in crashpad_database_util’s time conversions from numeric strings. A test is also added for the previously-untested uint64_t implementation. TEST=crashpad_util_test StringNumberConversion.* Change-Id: I089c4bf7b95f5df0982bdbb3c27b4f6a89db966e Reviewed-on: https://chromium-review.googlesource.com/410068 Reviewed-by: Robert Sesek <rsesek@chromium.org>
2016-11-15 13:50:32 -05:00
<< "index " << index << ", string " << kTestData[index].string;
}
} else {
EXPECT_FALSE(valid) << "index " << index << ", string "
<< kTestData[index].string << ", value " << value;
}
}
}
Add string_number_conversion and its test. This includes the StringToNumber() function, both int and unsigned int variants. Similar functionality is available in base, but it is unsuitable for applications where a number’s base may be determined based on an "0x" or "0X" prefix (hexadecimal) or an "0" prefix (octal). TEST=util_test StringNumberConversion.* R=rsesek@chromium.org Review URL: https://codereview.chromium.org/557033002
2014-09-10 15:30:11 -04:00
} // namespace
Don’t use using directives (“using namespace”) in tests. The contents of tests are moved into the namespace crashpad::test::(anonymous namespace). https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Namespaces R=rsesek@chromium.org Review URL: https://codereview.chromium.org/635883002
2014-10-07 17:28:50 -04:00
} // namespace test
} // namespace crashpad
Reference in New Issue Copy Permalink