Index: base/debug/stack_trace_unittest.cc |
diff --git a/base/debug/stack_trace_unittest.cc b/base/debug/stack_trace_unittest.cc |
index b676327d7a41c820f2937c19557f8ccab73a0071..0b3fff2c9aa5ee9aad7c0aa52b64fa2ef4d4df9a 100644 |
--- a/base/debug/stack_trace_unittest.cc |
+++ b/base/debug/stack_trace_unittest.cc |
@@ -6,6 +6,7 @@ |
#include <sstream> |
#include <string> |
+#include "base/debug/format.h" |
#include "base/debug/stack_trace.h" |
#include "base/logging.h" |
#include "base/process/kill.h" |
@@ -152,76 +153,82 @@ TEST_F(StackTraceTest, AsyncSignalUnsafeSignalHandlerHang) { |
namespace { |
-std::string itoa_r_wrapper(intptr_t i, size_t sz, int base, size_t padding) { |
- char buffer[1024]; |
+std::string itoa_r(intptr_t i, size_t sz, int base, size_t padding) { |
jln (very slow on Chromium)
2013/08/01 00:03:15
I wonder if you shouldn't expose itoa_r() and just
|
+ // The stack tracer uses Format() to convert integer values to ASCII. |
+ // It doesn't need all of the features of Format(), but instead restricts |
+ // itself to a subset that can be thought of as an itoa_r() function. |
+ char buffer[130]; |
CHECK_LE(sz, sizeof(buffer)); |
- |
- char* result = internal::itoa_r(i, buffer, sz, base, padding); |
- EXPECT_TRUE(result); |
+ CHECK_LE(sizeof(intptr_t)*8+1, sizeof(buffer)); |
+ char format[40]; |
+ EXPECT_TRUE(base == 10 || base == 16); |
+ CHECK_LT(Format(format, "%%0%d%c", padding, base == 10 ? 'd' : 'x'), |
+ static_cast<ssize_t>(sizeof(format))); |
+ CHECK_LT(FormatN(buffer, sz, format, i), |
+ static_cast<ssize_t>(sizeof(buffer))); |
return std::string(buffer); |
} |
} // namespace |
TEST_F(StackTraceTest, itoa_r) { |
- EXPECT_EQ("0", itoa_r_wrapper(0, 128, 10, 0)); |
- EXPECT_EQ("-1", itoa_r_wrapper(-1, 128, 10, 0)); |
+ EXPECT_EQ("0", itoa_r(0, 128, 10, 0)); |
+ EXPECT_EQ("-1", itoa_r(-1, 128, 10, 0)); |
// Test edge cases. |
if (sizeof(intptr_t) == 4) { |
- EXPECT_EQ("ffffffff", itoa_r_wrapper(-1, 128, 16, 0)); |
+ EXPECT_EQ("ffffffff", itoa_r(-1, 128, 16, 0)); |
EXPECT_EQ("-2147483648", |
- itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 10, 0)); |
+ itoa_r(std::numeric_limits<intptr_t>::min(), 128, 10, 0)); |
EXPECT_EQ("2147483647", |
- itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 10, 0)); |
+ itoa_r(std::numeric_limits<intptr_t>::max(), 128, 10, 0)); |
EXPECT_EQ("80000000", |
- itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 16, 0)); |
+ itoa_r(std::numeric_limits<intptr_t>::min(), 128, 16, 0)); |
EXPECT_EQ("7fffffff", |
- itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 16, 0)); |
+ itoa_r(std::numeric_limits<intptr_t>::max(), 128, 16, 0)); |
} else if (sizeof(intptr_t) == 8) { |
- EXPECT_EQ("ffffffffffffffff", itoa_r_wrapper(-1, 128, 16, 0)); |
+ EXPECT_EQ("ffffffffffffffff", itoa_r(-1, 128, 16, 0)); |
EXPECT_EQ("-9223372036854775808", |
- itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 10, 0)); |
+ itoa_r(std::numeric_limits<intptr_t>::min(), 128, 10, 0)); |
EXPECT_EQ("9223372036854775807", |
- itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 10, 0)); |
+ itoa_r(std::numeric_limits<intptr_t>::max(), 128, 10, 0)); |
EXPECT_EQ("8000000000000000", |
- itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 16, 0)); |
+ itoa_r(std::numeric_limits<intptr_t>::min(), 128, 16, 0)); |
EXPECT_EQ("7fffffffffffffff", |
- itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 16, 0)); |
+ itoa_r(std::numeric_limits<intptr_t>::max(), 128, 16, 0)); |
} else { |
ADD_FAILURE() << "Missing test case for your size of intptr_t (" |
<< sizeof(intptr_t) << ")"; |
} |
// Test hex output. |
- EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 0)); |
- EXPECT_EQ("deadbeef", itoa_r_wrapper(0xdeadbeef, 128, 16, 0)); |
+ EXPECT_EQ("688", itoa_r(0x688, 128, 16, 0)); |
+ EXPECT_EQ("deadbeef", itoa_r(0xdeadbeef, 128, 16, 0)); |
// Check that itoa_r respects passed buffer size limit. |
- char buffer[1024]; |
- EXPECT_TRUE(internal::itoa_r(0xdeadbeef, buffer, 10, 16, 0)); |
- EXPECT_TRUE(internal::itoa_r(0xdeadbeef, buffer, 9, 16, 0)); |
- EXPECT_FALSE(internal::itoa_r(0xdeadbeef, buffer, 8, 16, 0)); |
- EXPECT_FALSE(internal::itoa_r(0xdeadbeef, buffer, 7, 16, 0)); |
- EXPECT_TRUE(internal::itoa_r(0xbeef, buffer, 5, 16, 4)); |
- EXPECT_FALSE(internal::itoa_r(0xbeef, buffer, 5, 16, 5)); |
- EXPECT_FALSE(internal::itoa_r(0xbeef, buffer, 5, 16, 6)); |
+ EXPECT_EQ("deadbeef", itoa_r(0xdeadbeef, 10, 16, 0)); |
+ EXPECT_EQ("deadbeef", itoa_r(0xdeadbeef, 9, 16, 0)); |
+ EXPECT_EQ("deadbee", itoa_r(0xdeadbeef, 8, 16, 0)); |
+ EXPECT_EQ("deadbe", itoa_r(0xdeadbeef, 7, 16, 0)); |
+ EXPECT_EQ("beef", itoa_r(0xbeef, 5, 16, 4)); |
+ EXPECT_EQ("0bee", itoa_r(0xbeef, 5, 16, 5)); |
+ EXPECT_EQ("00be", itoa_r(0xbeef, 5, 16, 6)); |
// Test padding. |
- EXPECT_EQ("1", itoa_r_wrapper(1, 128, 10, 0)); |
- EXPECT_EQ("1", itoa_r_wrapper(1, 128, 10, 1)); |
- EXPECT_EQ("01", itoa_r_wrapper(1, 128, 10, 2)); |
- EXPECT_EQ("001", itoa_r_wrapper(1, 128, 10, 3)); |
- EXPECT_EQ("0001", itoa_r_wrapper(1, 128, 10, 4)); |
- EXPECT_EQ("00001", itoa_r_wrapper(1, 128, 10, 5)); |
- EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 0)); |
- EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 1)); |
- EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 2)); |
- EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 3)); |
- EXPECT_EQ("0688", itoa_r_wrapper(0x688, 128, 16, 4)); |
- EXPECT_EQ("00688", itoa_r_wrapper(0x688, 128, 16, 5)); |
+ EXPECT_EQ("1", itoa_r(1, 128, 10, 0)); |
+ EXPECT_EQ("1", itoa_r(1, 128, 10, 1)); |
+ EXPECT_EQ("01", itoa_r(1, 128, 10, 2)); |
+ EXPECT_EQ("001", itoa_r(1, 128, 10, 3)); |
+ EXPECT_EQ("0001", itoa_r(1, 128, 10, 4)); |
+ EXPECT_EQ("00001", itoa_r(1, 128, 10, 5)); |
+ EXPECT_EQ("688", itoa_r(0x688, 128, 16, 0)); |
+ EXPECT_EQ("688", itoa_r(0x688, 128, 16, 1)); |
+ EXPECT_EQ("688", itoa_r(0x688, 128, 16, 2)); |
+ EXPECT_EQ("688", itoa_r(0x688, 128, 16, 3)); |
+ EXPECT_EQ("0688", itoa_r(0x688, 128, 16, 4)); |
+ EXPECT_EQ("00688", itoa_r(0x688, 128, 16, 5)); |
} |
#endif // defined(OS_POSIX) && !defined(OS_ANDROID) |