Fix win unit tests broken at 9778206.
[pdfium.git] / core / src / fxcrt / fx_system_unittest.cpp
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 <string>
6
7 #include "testing/gtest/include/gtest/gtest.h"
8 #include "../../../testing/fx_string_testhelpers.h"
9 #include "../../include/fxcrt/fx_system.h"
10
11 // Unit test covering cases where PDFium replaces well-known library
12 // functionality on any given platformn.
13 namespace {
14
15 const FX_CHAR kSentinel = 0x7f;
16
17 void Check32BitBase16Itoa(int32_t input, const char* expected_output) {
18   const size_t kBufLen = 11;  // "-" + 8 digits + NUL + sentinel.
19   FX_CHAR buf[kBufLen];
20   buf[kBufLen - 1] = kSentinel;
21   FXSYS_itoa(input, buf, 16);
22   EXPECT_EQ(std::string(expected_output), buf);
23   EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
24 }
25
26 void Check32BitBase10Itoa(int32_t input, const char* expected_output) {
27   const size_t kBufLen = 13;  // "-" + 10 digits + NUL + sentinel.
28   FX_CHAR buf[kBufLen];
29   buf[kBufLen - 1] = kSentinel;
30   FXSYS_itoa(input, buf, 10);
31   EXPECT_EQ(std::string(expected_output), buf);
32   EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
33 }
34
35 void Check32BitBase2Itoa(int32_t input, const char* expected_output) {
36   const size_t kBufLen = 35;  // "-" + 32 digits + NUL + sentinel.
37   FX_CHAR buf[kBufLen];
38   buf[kBufLen - 1] = kSentinel;
39   FXSYS_itoa(input, buf, 2);
40   EXPECT_EQ(std::string(expected_output), buf);
41   EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
42 }
43
44 void Check64BitBase16Itoa(int64_t input, const char* expected_output) {
45   const size_t kBufLen = 19;  // "-" + 16 digits + NUL + sentinel.
46   FX_CHAR buf[kBufLen];
47   buf[kBufLen - 1] = kSentinel;
48   FXSYS_i64toa(input, buf, 16);
49   EXPECT_EQ(std::string(expected_output), buf);
50   EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
51 }
52
53 void Check64BitBase10Itoa(int64_t input, const char* expected_output) {
54   const size_t kBufLen = 22;  // "-" + 19 digits + NUL + sentinel.
55   FX_CHAR buf[kBufLen];
56   buf[kBufLen - 1] = kSentinel;
57   FXSYS_i64toa(input, buf, 10);
58   EXPECT_EQ(std::string(expected_output), buf);
59   EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
60 }
61
62 void Check64BitBase2Itoa(int64_t input, const char* expected_output) {
63   const size_t kBufLen = 67;  // "-" + 64 digits + NUL + sentinel.
64   FX_CHAR buf[kBufLen];
65   buf[kBufLen - 1] = kSentinel;
66   FXSYS_i64toa(input, buf, 2);
67   EXPECT_EQ(std::string(expected_output), buf);
68   EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
69 }
70
71 }  // namespace
72
73 TEST(fxcrt, FXSYS_itoa_InvalidRadix) {
74   FX_CHAR buf[32];
75
76 #if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
77   FXSYS_itoa(42, buf, 17);  // Ours stops at 16.
78 #else
79   FXSYS_itoa(42, buf, 37);  // Theirs goes up to 36.
80 #endif
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
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
117
118 TEST(fxcrt, FXSYS_i64toa_InvalidRadix) {
119   FX_CHAR buf[32];
120
121 #if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
122   FXSYS_i64toa(42, buf, 17);  // Ours stops at 16.
123 #else
124   FXSYS_i64toa(42, buf, 37);  // Theirs goes up to 36.
125 #endif
126   EXPECT_EQ(std::string(""), buf);
127
128   FXSYS_i64toa(42, buf, 1);
129   EXPECT_EQ(std::string(""), buf);
130
131   FXSYS_i64toa(42, buf, 0);
132   EXPECT_EQ(std::string(""), buf);
133
134   FXSYS_i64toa(42, buf, -1);
135   EXPECT_EQ(std::string(""), buf);
136 };
137
138 TEST(fxcrt, FXSYS_i64toa) {
139   Check64BitBase16Itoa(
140       std::numeric_limits<int64_t>::min(), "-8000000000000000");
141   Check64BitBase10Itoa(
142       std::numeric_limits<int64_t>::min(), "-9223372036854775808");
143   Check64BitBase2Itoa(
144       std::numeric_limits<int64_t>::min(),
145       "-1000000000000000000000000000000000000000000000000000000000000000");
146
147   Check64BitBase16Itoa(-1, "-1");
148   Check64BitBase10Itoa(-1, "-1");
149   Check64BitBase2Itoa(-1, "-1");
150
151   Check64BitBase16Itoa(0, "0");
152   Check64BitBase10Itoa(0, "0");
153   Check64BitBase2Itoa(0, "0");
154
155   Check64BitBase16Itoa(42, "2a");
156   Check64BitBase10Itoa(42, "42");
157   Check64BitBase2Itoa(42, "101010");
158
159   Check64BitBase16Itoa(
160       std::numeric_limits<int64_t>::max(), "7fffffffffffffff");
161   Check64BitBase10Itoa(
162       std::numeric_limits<int64_t>::max(), "9223372036854775807");
163   Check64BitBase2Itoa(
164       std::numeric_limits<int64_t>::max(),
165       "111111111111111111111111111111111111111111111111111111111111111");
166 }