1 // Copyright 2013 The Chromium 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 "base/strings/stringprintf.h"
6
7 #include <errno.h>
8 #include <stddef.h>
9
10 #include "base/macros.h"
11 #include "build/build_config.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13
14 namespace base {
15
16 namespace {
17
18 // A helper for the StringAppendV test that follows.
19 //
20 // Just forwards its args to StringAppendV.
StringAppendVTestHelper(std::string * out,const char * format,...)21 static void StringAppendVTestHelper(std::string* out, const char* format, ...) {
22 va_list ap;
23 va_start(ap, format);
24 StringAppendV(out, format, ap);
25 va_end(ap);
26 }
27
28 } // namespace
29
TEST(StringPrintfTest,StringPrintfEmpty)30 TEST(StringPrintfTest, StringPrintfEmpty) {
31 EXPECT_EQ("", StringPrintf("%s", ""));
32 }
33
TEST(StringPrintfTest,StringPrintfMisc)34 TEST(StringPrintfTest, StringPrintfMisc) {
35 EXPECT_EQ("123hello w", StringPrintf("%3d%2s %1c", 123, "hello", 'w'));
36 #if defined(OS_WIN)
37 EXPECT_EQ(L"123hello w", StringPrintf(L"%3d%2ls %1lc", 123, L"hello", 'w'));
38 #endif
39 }
40
TEST(StringPrintfTest,StringAppendfEmptyString)41 TEST(StringPrintfTest, StringAppendfEmptyString) {
42 std::string value("Hello");
43 StringAppendF(&value, "%s", "");
44 EXPECT_EQ("Hello", value);
45
46 #if defined(OS_WIN)
47 std::wstring valuew(L"Hello");
48 StringAppendF(&valuew, L"%ls", L"");
49 EXPECT_EQ(L"Hello", valuew);
50 #endif
51 }
52
TEST(StringPrintfTest,StringAppendfString)53 TEST(StringPrintfTest, StringAppendfString) {
54 std::string value("Hello");
55 StringAppendF(&value, " %s", "World");
56 EXPECT_EQ("Hello World", value);
57
58 #if defined(OS_WIN)
59 std::wstring valuew(L"Hello");
60 StringAppendF(&valuew, L" %ls", L"World");
61 EXPECT_EQ(L"Hello World", valuew);
62 #endif
63 }
64
TEST(StringPrintfTest,StringAppendfInt)65 TEST(StringPrintfTest, StringAppendfInt) {
66 std::string value("Hello");
67 StringAppendF(&value, " %d", 123);
68 EXPECT_EQ("Hello 123", value);
69
70 #if defined(OS_WIN)
71 std::wstring valuew(L"Hello");
72 StringAppendF(&valuew, L" %d", 123);
73 EXPECT_EQ(L"Hello 123", valuew);
74 #endif
75 }
76
77 // Make sure that lengths exactly around the initial buffer size are handled
78 // correctly.
TEST(StringPrintfTest,StringPrintfBounds)79 TEST(StringPrintfTest, StringPrintfBounds) {
80 const int kSrcLen = 1026;
81 char src[kSrcLen];
82 for (size_t i = 0; i < arraysize(src); i++)
83 src[i] = 'A';
84
85 wchar_t srcw[kSrcLen];
86 for (size_t i = 0; i < arraysize(srcw); i++)
87 srcw[i] = 'A';
88
89 for (int i = 1; i < 3; i++) {
90 src[kSrcLen - i] = 0;
91 std::string out;
92 SStringPrintf(&out, "%s", src);
93 EXPECT_STREQ(src, out.c_str());
94
95 #if defined(OS_WIN)
96 srcw[kSrcLen - i] = 0;
97 std::wstring outw;
98 SStringPrintf(&outw, L"%ls", srcw);
99 EXPECT_STREQ(srcw, outw.c_str());
100 #endif
101 }
102 }
103
104 // Test very large sprintfs that will cause the buffer to grow.
TEST(StringPrintfTest,Grow)105 TEST(StringPrintfTest, Grow) {
106 char src[1026];
107 for (size_t i = 0; i < arraysize(src); i++)
108 src[i] = 'A';
109 src[1025] = 0;
110
111 const char fmt[] = "%sB%sB%sB%sB%sB%sB%s";
112
113 std::string out;
114 SStringPrintf(&out, fmt, src, src, src, src, src, src, src);
115
116 const int kRefSize = 320000;
117 char* ref = new char[kRefSize];
118 #if defined(OS_WIN)
119 sprintf_s(ref, kRefSize, fmt, src, src, src, src, src, src, src);
120 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
121 snprintf(ref, kRefSize, fmt, src, src, src, src, src, src, src);
122 #endif
123
124 EXPECT_STREQ(ref, out.c_str());
125 delete[] ref;
126 }
127
TEST(StringPrintfTest,StringAppendV)128 TEST(StringPrintfTest, StringAppendV) {
129 std::string out;
130 StringAppendVTestHelper(&out, "%d foo %s", 1, "bar");
131 EXPECT_EQ("1 foo bar", out);
132 }
133
134 // Test the boundary condition for the size of the string_util's
135 // internal buffer.
TEST(StringPrintfTest,GrowBoundary)136 TEST(StringPrintfTest, GrowBoundary) {
137 const int kStringUtilBufLen = 1024;
138 // Our buffer should be one larger than the size of StringAppendVT's stack
139 // buffer.
140 // And need extra one for NULL-terminator.
141 const int kBufLen = kStringUtilBufLen + 1 + 1;
142 char src[kBufLen];
143 for (int i = 0; i < kBufLen - 1; ++i)
144 src[i] = 'a';
145 src[kBufLen - 1] = 0;
146
147 std::string out;
148 SStringPrintf(&out, "%s", src);
149
150 EXPECT_STREQ(src, out.c_str());
151 }
152
153 #if defined(OS_WIN)
154 // vswprintf in Visual Studio 2013 fails when given U+FFFF. This tests that the
155 // failure case is gracefuly handled. In Visual Studio 2015 the bad character
156 // is passed through.
TEST(StringPrintfTest,Invalid)157 TEST(StringPrintfTest, Invalid) {
158 wchar_t invalid[2];
159 invalid[0] = 0xffff;
160 invalid[1] = 0;
161
162 std::wstring out;
163 SStringPrintf(&out, L"%ls", invalid);
164 #if _MSC_VER >= 1900
165 EXPECT_STREQ(invalid, out.c_str());
166 #else
167 EXPECT_STREQ(L"", out.c_str());
168 #endif
169 }
170 #endif
171
172 // Test that StringPrintf and StringAppendV do not change errno.
TEST(StringPrintfTest,StringPrintfErrno)173 TEST(StringPrintfTest, StringPrintfErrno) {
174 errno = 1;
175 EXPECT_EQ("", StringPrintf("%s", ""));
176 EXPECT_EQ(1, errno);
177 std::string out;
178 StringAppendVTestHelper(&out, "%d foo %s", 1, "bar");
179 EXPECT_EQ(1, errno);
180 }
181
182 } // namespace base
183