base/stringprintf_unittest.cc

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