1 // Copyright 2015 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <limits>
6 #include <string>
7
8 #include "core/fxcrt/fx_system.h"
9 #include "testing/fx_string_testhelpers.h"
10 #include "testing/gtest/include/gtest/gtest.h"
11
12 // Unit test covering cases where PDFium replaces well-known library
13 // functionality on any given platformn.
14
15 #if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
16
17 namespace {
18
19 const FX_CHAR kSentinel = 0x7f;
20
Check32BitBase16Itoa(int32_t input,const char * expected_output)21 void Check32BitBase16Itoa(int32_t input, const char* expected_output) {
22 const size_t kBufLen = 11; // "-" + 8 digits + NUL + sentinel.
23 FX_CHAR buf[kBufLen];
24 buf[kBufLen - 1] = kSentinel;
25 FXSYS_itoa(input, buf, 16);
26 EXPECT_EQ(std::string(expected_output), buf);
27 EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
28 }
29
Check32BitBase10Itoa(int32_t input,const char * expected_output)30 void Check32BitBase10Itoa(int32_t input, const char* expected_output) {
31 const size_t kBufLen = 13; // "-" + 10 digits + NUL + sentinel.
32 FX_CHAR buf[kBufLen];
33 buf[kBufLen - 1] = kSentinel;
34 FXSYS_itoa(input, buf, 10);
35 EXPECT_EQ(std::string(expected_output), buf);
36 EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
37 }
38
Check32BitBase2Itoa(int32_t input,const char * expected_output)39 void Check32BitBase2Itoa(int32_t input, const char* expected_output) {
40 const size_t kBufLen = 35; // "-" + 32 digits + NUL + sentinel.
41 FX_CHAR buf[kBufLen];
42 buf[kBufLen - 1] = kSentinel;
43 FXSYS_itoa(input, buf, 2);
44 EXPECT_EQ(std::string(expected_output), buf);
45 EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
46 }
47
Check64BitBase16Itoa(int64_t input,const char * expected_output)48 void Check64BitBase16Itoa(int64_t input, const char* expected_output) {
49 const size_t kBufLen = 19; // "-" + 16 digits + NUL + sentinel.
50 FX_CHAR buf[kBufLen];
51 buf[kBufLen - 1] = kSentinel;
52 FXSYS_i64toa(input, buf, 16);
53 EXPECT_EQ(std::string(expected_output), buf);
54 EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
55 }
56
Check64BitBase10Itoa(int64_t input,const char * expected_output)57 void Check64BitBase10Itoa(int64_t input, const char* expected_output) {
58 const size_t kBufLen = 22; // "-" + 19 digits + NUL + sentinel.
59 FX_CHAR buf[kBufLen];
60 buf[kBufLen - 1] = kSentinel;
61 FXSYS_i64toa(input, buf, 10);
62 EXPECT_EQ(std::string(expected_output), buf);
63 EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
64 }
65
Check64BitBase2Itoa(int64_t input,const char * expected_output)66 void Check64BitBase2Itoa(int64_t input, const char* expected_output) {
67 const size_t kBufLen = 67; // "-" + 64 digits + NUL + sentinel.
68 FX_CHAR buf[kBufLen];
69 buf[kBufLen - 1] = kSentinel;
70 FXSYS_i64toa(input, buf, 2);
71 EXPECT_EQ(std::string(expected_output), buf);
72 EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
73 }
74
75 } // namespace
76
TEST(fxcrt,FXSYS_itoa_InvalidRadix)77 TEST(fxcrt, FXSYS_itoa_InvalidRadix) {
78 FX_CHAR buf[32];
79
80 FXSYS_itoa(42, buf, 17); // Ours stops at 16.
81 EXPECT_EQ(std::string(""), buf);
82
83 FXSYS_itoa(42, buf, 1);
84 EXPECT_EQ(std::string(""), buf);
85
86 FXSYS_itoa(42, buf, 0);
87 EXPECT_EQ(std::string(""), buf);
88
89 FXSYS_itoa(42, buf, -1);
90 EXPECT_EQ(std::string(""), buf);
91 }
92
TEST(fxcrt,FXSYS_itoa)93 TEST(fxcrt, FXSYS_itoa) {
94 Check32BitBase16Itoa(std::numeric_limits<int32_t>::min(), "-80000000");
95 Check32BitBase10Itoa(std::numeric_limits<int32_t>::min(), "-2147483648");
96 Check32BitBase2Itoa(std::numeric_limits<int32_t>::min(),
97 "-10000000000000000000000000000000");
98
99 Check32BitBase16Itoa(-1, "-1");
100 Check32BitBase10Itoa(-1, "-1");
101 Check32BitBase2Itoa(-1, "-1");
102
103 Check32BitBase16Itoa(0, "0");
104 Check32BitBase10Itoa(0, "0");
105 Check32BitBase2Itoa(0, "0");
106
107 Check32BitBase16Itoa(42, "2a");
108 Check32BitBase10Itoa(42, "42");
109 Check32BitBase2Itoa(42, "101010");
110
111 Check32BitBase16Itoa(std::numeric_limits<int32_t>::max(), "7fffffff");
112 Check32BitBase10Itoa(std::numeric_limits<int32_t>::max(), "2147483647");
113 Check32BitBase2Itoa(std::numeric_limits<int32_t>::max(),
114 "1111111111111111111111111111111");
115 }
116
TEST(fxcrt,FXSYS_i64toa_InvalidRadix)117 TEST(fxcrt, FXSYS_i64toa_InvalidRadix) {
118 FX_CHAR buf[32];
119
120 FXSYS_i64toa(42, buf, 17); // Ours stops at 16.
121 EXPECT_EQ(std::string(""), buf);
122
123 FXSYS_i64toa(42, buf, 1);
124 EXPECT_EQ(std::string(""), buf);
125
126 FXSYS_i64toa(42, buf, 0);
127 EXPECT_EQ(std::string(""), buf);
128
129 FXSYS_i64toa(42, buf, -1);
130 EXPECT_EQ(std::string(""), buf);
131 }
132
TEST(fxcrt,FXSYS_i64toa)133 TEST(fxcrt, FXSYS_i64toa) {
134 Check64BitBase16Itoa(std::numeric_limits<int64_t>::min(),
135 "-8000000000000000");
136 Check64BitBase10Itoa(std::numeric_limits<int64_t>::min(),
137 "-9223372036854775808");
138 Check64BitBase2Itoa(
139 std::numeric_limits<int64_t>::min(),
140 "-1000000000000000000000000000000000000000000000000000000000000000");
141
142 Check64BitBase16Itoa(-1, "-1");
143 Check64BitBase10Itoa(-1, "-1");
144 Check64BitBase2Itoa(-1, "-1");
145
146 Check64BitBase16Itoa(0, "0");
147 Check64BitBase10Itoa(0, "0");
148 Check64BitBase2Itoa(0, "0");
149
150 Check64BitBase16Itoa(42, "2a");
151 Check64BitBase10Itoa(42, "42");
152 Check64BitBase2Itoa(42, "101010");
153
154 Check64BitBase16Itoa(std::numeric_limits<int64_t>::max(), "7fffffffffffffff");
155 Check64BitBase10Itoa(std::numeric_limits<int64_t>::max(),
156 "9223372036854775807");
157 Check64BitBase2Itoa(
158 std::numeric_limits<int64_t>::max(),
159 "111111111111111111111111111111111111111111111111111111111111111");
160 }
161
162 #endif // _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
163