Subversion Repositories s80186

// Copyright 2007, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Author: wan@google.com (Zhanyong Wan)

// Google Test - The Google C++ Testing Framework

//

// This file tests the universal value printer.

#include "gtest/gtest-printers.h"

#include <ctype.h>

#include <limits.h>

#include <string.h>

#include <algorithm>

#include <deque>

#include <list>

#include <map>

#include <set>

#include <sstream>

#include <string>

#include <utility>

#include <vector>

#include "gtest/gtest.h"

// hash_map and hash_set are available under Visual C++, or on Linux.

#if GTEST_HAS_HASH_MAP_

# include <hash_map>            // NOLINT

#endif  // GTEST_HAS_HASH_MAP_

#if GTEST_HAS_HASH_SET_

# include <hash_set>            // NOLINT

#endif  // GTEST_HAS_HASH_SET_

#if GTEST_HAS_STD_FORWARD_LIST_

# include <forward_list> // NOLINT

#endif  // GTEST_HAS_STD_FORWARD_LIST_

// Some user-defined types for testing the universal value printer.

// An anonymous enum type.

enum AnonymousEnum {

  kAE1 = -1,

  kAE2 = 1

};

// An enum without a user-defined printer.

enum EnumWithoutPrinter {

  kEWP1 = -2,

  kEWP2 = 42

};

// An enum with a << operator.

enum EnumWithStreaming {

  kEWS1 = 10

};

std::ostream& operator<<(std::ostream& os, EnumWithStreaming e) {

  return os << (e == kEWS1 ? "kEWS1" : "invalid");

}

// An enum with a PrintTo() function.

enum EnumWithPrintTo {

  kEWPT1 = 1

};

void PrintTo(EnumWithPrintTo e, std::ostream* os) {

  *os << (e == kEWPT1 ? "kEWPT1" : "invalid");

}

// A class implicitly convertible to BiggestInt.

class BiggestIntConvertible {

 public:

  operator ::testing::internal::BiggestInt() const { return 42; }

};

// A user-defined unprintable class template in the global namespace.

template <typename T>

class UnprintableTemplateInGlobal {

 public:

  UnprintableTemplateInGlobal() : value_() {}

 private:

  T value_;

};

// A user-defined streamable type in the global namespace.

class StreamableInGlobal {

 public:

  virtual ~StreamableInGlobal() {}

};

inline void operator<<(::std::ostream& os, const StreamableInGlobal& /* x */) {

  os << "StreamableInGlobal";

}

void operator<<(::std::ostream& os, const StreamableInGlobal* /* x */) {

  os << "StreamableInGlobal*";

}

namespace foo {

// A user-defined unprintable type in a user namespace.

class UnprintableInFoo {

 public:

  UnprintableInFoo() : z_(0) { memcpy(xy_, "\xEF\x12\x0\x0\x34\xAB\x0\x0", 8); }

  double z() const { return z_; }

 private:

  char xy_[8];

  double z_;

};

// A user-defined printable type in a user-chosen namespace.

struct PrintableViaPrintTo {

  PrintableViaPrintTo() : value() {}

  int value;

};

void PrintTo(const PrintableViaPrintTo& x, ::std::ostream* os) {

  *os << "PrintableViaPrintTo: " << x.value;

}

// A type with a user-defined << for printing its pointer.

struct PointerPrintable {

};

::std::ostream& operator<<(::std::ostream& os,

                           const PointerPrintable* /* x */) {

  return os << "PointerPrintable*";

}

// A user-defined printable class template in a user-chosen namespace.

template <typename T>

class PrintableViaPrintToTemplate {

 public:

  explicit PrintableViaPrintToTemplate(const T& a_value) : value_(a_value) {}

  const T& value() const { return value_; }

 private:

  T value_;

};

template <typename T>

void PrintTo(const PrintableViaPrintToTemplate<T>& x, ::std::ostream* os) {

  *os << "PrintableViaPrintToTemplate: " << x.value();

}

// A user-defined streamable class template in a user namespace.

template <typename T>

class StreamableTemplateInFoo {

 public:

  StreamableTemplateInFoo() : value_() {}

  const T& value() const { return value_; }

 private:

  T value_;

};

template <typename T>

inline ::std::ostream& operator<<(::std::ostream& os,

                                  const StreamableTemplateInFoo<T>& x) {

  return os << "StreamableTemplateInFoo: " << x.value();

}

}  // namespace foo

namespace testing {

namespace gtest_printers_test {

using ::std::deque;

using ::std::list;

using ::std::make_pair;

using ::std::map;

using ::std::multimap;

using ::std::multiset;

using ::std::pair;

using ::std::set;

using ::std::vector;

using ::testing::PrintToString;

using ::testing::internal::FormatForComparisonFailureMessage;

using ::testing::internal::ImplicitCast_;

using ::testing::internal::NativeArray;

using ::testing::internal::RE;

using ::testing::internal::RelationToSourceReference;

using ::testing::internal::Strings;

using ::testing::internal::UniversalPrint;

using ::testing::internal::UniversalPrinter;

using ::testing::internal::UniversalTersePrint;

using ::testing::internal::UniversalTersePrintTupleFieldsToStrings;

using ::testing::internal::string;

// The hash_* classes are not part of the C++ standard.  STLport

// defines them in namespace std.  MSVC defines them in ::stdext.  GCC

// defines them in ::.

#ifdef _STLP_HASH_MAP  // We got <hash_map> from STLport.

using ::std::hash_map;

using ::std::hash_set;

using ::std::hash_multimap;

using ::std::hash_multiset;

#elif _MSC_VER

using ::stdext::hash_map;

using ::stdext::hash_set;

using ::stdext::hash_multimap;

using ::stdext::hash_multiset;

#endif

// Prints a value to a string using the universal value printer.  This

// is a helper for testing UniversalPrinter<T>::Print() for various types.

template <typename T>

string Print(const T& value) {

  ::std::stringstream ss;

  UniversalPrinter<T>::Print(value, &ss);

  return ss.str();

}

// Prints a value passed by reference to a string, using the universal

// value printer.  This is a helper for testing

// UniversalPrinter<T&>::Print() for various types.

template <typename T>

string PrintByRef(const T& value) {

  ::std::stringstream ss;

  UniversalPrinter<T&>::Print(value, &ss);

  return ss.str();

}

// Tests printing various enum types.

TEST(PrintEnumTest, AnonymousEnum) {

  EXPECT_EQ("-1", Print(kAE1));

  EXPECT_EQ("1", Print(kAE2));

}

TEST(PrintEnumTest, EnumWithoutPrinter) {

  EXPECT_EQ("-2", Print(kEWP1));

  EXPECT_EQ("42", Print(kEWP2));

}

TEST(PrintEnumTest, EnumWithStreaming) {

  EXPECT_EQ("kEWS1", Print(kEWS1));

  EXPECT_EQ("invalid", Print(static_cast<EnumWithStreaming>(0)));

}

TEST(PrintEnumTest, EnumWithPrintTo) {

  EXPECT_EQ("kEWPT1", Print(kEWPT1));

  EXPECT_EQ("invalid", Print(static_cast<EnumWithPrintTo>(0)));

}

// Tests printing a class implicitly convertible to BiggestInt.

TEST(PrintClassTest, BiggestIntConvertible) {

  EXPECT_EQ("42", Print(BiggestIntConvertible()));

}

// Tests printing various char types.

// char.

TEST(PrintCharTest, PlainChar) {

  EXPECT_EQ("'\\0'", Print('\0'));

  EXPECT_EQ("'\\'' (39, 0x27)", Print('\''));

  EXPECT_EQ("'\"' (34, 0x22)", Print('"'));

  EXPECT_EQ("'?' (63, 0x3F)", Print('?'));

  EXPECT_EQ("'\\\\' (92, 0x5C)", Print('\\'));

  EXPECT_EQ("'\\a' (7)", Print('\a'));

  EXPECT_EQ("'\\b' (8)", Print('\b'));

  EXPECT_EQ("'\\f' (12, 0xC)", Print('\f'));

  EXPECT_EQ("'\\n' (10, 0xA)", Print('\n'));

  EXPECT_EQ("'\\r' (13, 0xD)", Print('\r'));

  EXPECT_EQ("'\\t' (9)", Print('\t'));

  EXPECT_EQ("'\\v' (11, 0xB)", Print('\v'));

  EXPECT_EQ("'\\x7F' (127)", Print('\x7F'));

  EXPECT_EQ("'\\xFF' (255)", Print('\xFF'));

  EXPECT_EQ("' ' (32, 0x20)", Print(' '));

  EXPECT_EQ("'a' (97, 0x61)", Print('a'));

}

// signed char.

TEST(PrintCharTest, SignedChar) {

  EXPECT_EQ("'\\0'", Print(static_cast<signed char>('\0')));

  EXPECT_EQ("'\\xCE' (-50)",

            Print(static_cast<signed char>(-50)));

}

// unsigned char.

TEST(PrintCharTest, UnsignedChar) {

  EXPECT_EQ("'\\0'", Print(static_cast<unsigned char>('\0')));

  EXPECT_EQ("'b' (98, 0x62)",

            Print(static_cast<unsigned char>('b')));

}

// Tests printing other simple, built-in types.

// bool.

TEST(PrintBuiltInTypeTest, Bool) {

  EXPECT_EQ("false", Print(false));

  EXPECT_EQ("true", Print(true));

}

// wchar_t.

TEST(PrintBuiltInTypeTest, Wchar_t) {

  EXPECT_EQ("L'\\0'", Print(L'\0'));

  EXPECT_EQ("L'\\'' (39, 0x27)", Print(L'\''));

  EXPECT_EQ("L'\"' (34, 0x22)", Print(L'"'));

  EXPECT_EQ("L'?' (63, 0x3F)", Print(L'?'));

  EXPECT_EQ("L'\\\\' (92, 0x5C)", Print(L'\\'));

  EXPECT_EQ("L'\\a' (7)", Print(L'\a'));

  EXPECT_EQ("L'\\b' (8)", Print(L'\b'));

  EXPECT_EQ("L'\\f' (12, 0xC)", Print(L'\f'));

  EXPECT_EQ("L'\\n' (10, 0xA)", Print(L'\n'));

  EXPECT_EQ("L'\\r' (13, 0xD)", Print(L'\r'));

  EXPECT_EQ("L'\\t' (9)", Print(L'\t'));

  EXPECT_EQ("L'\\v' (11, 0xB)", Print(L'\v'));

  EXPECT_EQ("L'\\x7F' (127)", Print(L'\x7F'));

  EXPECT_EQ("L'\\xFF' (255)", Print(L'\xFF'));

  EXPECT_EQ("L' ' (32, 0x20)", Print(L' '));

  EXPECT_EQ("L'a' (97, 0x61)", Print(L'a'));

  EXPECT_EQ("L'\\x576' (1398)", Print(static_cast<wchar_t>(0x576)));

  EXPECT_EQ("L'\\xC74D' (51021)", Print(static_cast<wchar_t>(0xC74D)));

}

// Test that Int64 provides more storage than wchar_t.

TEST(PrintTypeSizeTest, Wchar_t) {

  EXPECT_LT(sizeof(wchar_t), sizeof(testing::internal::Int64));

}

// Various integer types.

TEST(PrintBuiltInTypeTest, Integer) {

  EXPECT_EQ("'\\xFF' (255)", Print(static_cast<unsigned char>(255)));  // uint8

  EXPECT_EQ("'\\x80' (-128)", Print(static_cast<signed char>(-128)));  // int8

  EXPECT_EQ("65535", Print(USHRT_MAX));  // uint16

  EXPECT_EQ("-32768", Print(SHRT_MIN));  // int16

  EXPECT_EQ("4294967295", Print(UINT_MAX));  // uint32

  EXPECT_EQ("-2147483648", Print(INT_MIN));  // int32

  EXPECT_EQ("18446744073709551615",

            Print(static_cast<testing::internal::UInt64>(-1)));  // uint64

  EXPECT_EQ("-9223372036854775808",

            Print(static_cast<testing::internal::Int64>(1) << 63));  // int64

}

// Size types.

TEST(PrintBuiltInTypeTest, Size_t) {

  EXPECT_EQ("1", Print(sizeof('a')));  // size_t.

#if !GTEST_OS_WINDOWS

  // Windows has no ssize_t type.

  EXPECT_EQ("-2", Print(static_cast<ssize_t>(-2)));  // ssize_t.

#endif  // !GTEST_OS_WINDOWS

}

// Floating-points.

TEST(PrintBuiltInTypeTest, FloatingPoints) {

  EXPECT_EQ("1.5", Print(1.5f));   // float

  EXPECT_EQ("-2.5", Print(-2.5));  // double

}

// Since ::std::stringstream::operator<<(const void *) formats the pointer

// output differently with different compilers, we have to create the expected

// output first and use it as our expectation.

static string PrintPointer(const void *p) {

  ::std::stringstream expected_result_stream;

  expected_result_stream << p;

  return expected_result_stream.str();

}

// Tests printing C strings.

// const char*.

TEST(PrintCStringTest, Const) {

  const char* p = "World";

  EXPECT_EQ(PrintPointer(p) + " pointing to \"World\"", Print(p));

}

// char*.

TEST(PrintCStringTest, NonConst) {

  char p[] = "Hi";

  EXPECT_EQ(PrintPointer(p) + " pointing to \"Hi\"",

            Print(static_cast<char*>(p)));

}

// NULL C string.

TEST(PrintCStringTest, Null) {

  const char* p = NULL;

  EXPECT_EQ("NULL", Print(p));

}

// Tests that C strings are escaped properly.

TEST(PrintCStringTest, EscapesProperly) {

  const char* p = "'\"?\\\a\b\f\n\r\t\v\x7F\xFF a";

  EXPECT_EQ(PrintPointer(p) + " pointing to \"'\\\"?\\\\\\a\\b\\f"

            "\\n\\r\\t\\v\\x7F\\xFF a\"",

            Print(p));

}

// MSVC compiler can be configured to define whar_t as a typedef

// of unsigned short. Defining an overload for const wchar_t* in that case

// would cause pointers to unsigned shorts be printed as wide strings,

// possibly accessing more memory than intended and causing invalid

// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when

// wchar_t is implemented as a native type.

#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)

// const wchar_t*.

TEST(PrintWideCStringTest, Const) {

  const wchar_t* p = L"World";

  EXPECT_EQ(PrintPointer(p) + " pointing to L\"World\"", Print(p));

}

// wchar_t*.

TEST(PrintWideCStringTest, NonConst) {

  wchar_t p[] = L"Hi";

  EXPECT_EQ(PrintPointer(p) + " pointing to L\"Hi\"",

            Print(static_cast<wchar_t*>(p)));

}

// NULL wide C string.

TEST(PrintWideCStringTest, Null) {

  const wchar_t* p = NULL;

  EXPECT_EQ("NULL", Print(p));

}

// Tests that wide C strings are escaped properly.

TEST(PrintWideCStringTest, EscapesProperly) {

  const wchar_t s[] = {'\'', '"', '?', '\\', '\a', '\b', '\f', '\n', '\r',

                       '\t', '\v', 0xD3, 0x576, 0x8D3, 0xC74D, ' ', 'a', '\0'};

  EXPECT_EQ(PrintPointer(s) + " pointing to L\"'\\\"?\\\\\\a\\b\\f"

            "\\n\\r\\t\\v\\xD3\\x576\\x8D3\\xC74D a\"",

            Print(static_cast<const wchar_t*>(s)));

}

#endif  // native wchar_t

// Tests printing pointers to other char types.

// signed char*.

TEST(PrintCharPointerTest, SignedChar) {

  signed char* p = reinterpret_cast<signed char*>(0x1234);

  EXPECT_EQ(PrintPointer(p), Print(p));

  p = NULL;

  EXPECT_EQ("NULL", Print(p));

}

// const signed char*.

TEST(PrintCharPointerTest, ConstSignedChar) {

  signed char* p = reinterpret_cast<signed char*>(0x1234);

  EXPECT_EQ(PrintPointer(p), Print(p));

  p = NULL;

  EXPECT_EQ("NULL", Print(p));

}

// unsigned char*.

TEST(PrintCharPointerTest, UnsignedChar) {

  unsigned char* p = reinterpret_cast<unsigned char*>(0x1234);

  EXPECT_EQ(PrintPointer(p), Print(p));

  p = NULL;

  EXPECT_EQ("NULL", Print(p));

}

// const unsigned char*.

TEST(PrintCharPointerTest, ConstUnsignedChar) {

  const unsigned char* p = reinterpret_cast<const unsigned char*>(0x1234);

  EXPECT_EQ(PrintPointer(p), Print(p));

  p = NULL;

  EXPECT_EQ("NULL", Print(p));

}

// Tests printing pointers to simple, built-in types.

// bool*.

TEST(PrintPointerToBuiltInTypeTest, Bool) {

  bool* p = reinterpret_cast<bool*>(0xABCD);

  EXPECT_EQ(PrintPointer(p), Print(p));

  p = NULL;

  EXPECT_EQ("NULL", Print(p));

}

// void*.

TEST(PrintPointerToBuiltInTypeTest, Void) {

  void* p = reinterpret_cast<void*>(0xABCD);

  EXPECT_EQ(PrintPointer(p), Print(p));

  p = NULL;

  EXPECT_EQ("NULL", Print(p));

}

// const void*.

TEST(PrintPointerToBuiltInTypeTest, ConstVoid) {

  const void* p = reinterpret_cast<const void*>(0xABCD);

  EXPECT_EQ(PrintPointer(p), Print(p));

  p = NULL;

  EXPECT_EQ("NULL", Print(p));

}

// Tests printing pointers to pointers.

TEST(PrintPointerToPointerTest, IntPointerPointer) {

  int** p = reinterpret_cast<int**>(0xABCD);

  EXPECT_EQ(PrintPointer(p), Print(p));

  p = NULL;

  EXPECT_EQ("NULL", Print(p));

}

// Tests printing (non-member) function pointers.

void MyFunction(int /* n */) {}

TEST(PrintPointerTest, NonMemberFunctionPointer) {

  // We cannot directly cast &MyFunction to const void* because the

  // standard disallows casting between pointers to functions and

  // pointers to objects, and some compilers (e.g. GCC 3.4) enforce

  // this limitation.

  EXPECT_EQ(

      PrintPointer(reinterpret_cast<const void*>(

          reinterpret_cast<internal::BiggestInt>(&MyFunction))),

      Print(&MyFunction));

  int (*p)(bool) = NULL;  // NOLINT

  EXPECT_EQ("NULL", Print(p));

}

// An assertion predicate determining whether a one string is a prefix for

// another.

template <typename StringType>

AssertionResult HasPrefix(const StringType& str, const StringType& prefix) {

  if (str.find(prefix, 0) == 0)

    return AssertionSuccess();

  const bool is_wide_string = sizeof(prefix[0]) > 1;

  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";

  return AssertionFailure()

      << begin_string_quote << prefix << "\" is not a prefix of "

      << begin_string_quote << str << "\"\n";

}

// Tests printing member variable pointers.  Although they are called

// pointers, they don't point to a location in the address space.

// Their representation is implementation-defined.  Thus they will be

// printed as raw bytes.

struct Foo {

 public:

  virtual ~Foo() {}

  int MyMethod(char x) { return x + 1; }

  virtual char MyVirtualMethod(int /* n */) { return 'a'; }

  int value;

};

TEST(PrintPointerTest, MemberVariablePointer) {

  EXPECT_TRUE(HasPrefix(Print(&Foo::value),

                        Print(sizeof(&Foo::value)) + "-byte object "));

  int (Foo::*p) = NULL;  // NOLINT

  EXPECT_TRUE(HasPrefix(Print(p),

                        Print(sizeof(p)) + "-byte object "));

}

// Tests printing member function pointers.  Although they are called

// pointers, they don't point to a location in the address space.

// Their representation is implementation-defined.  Thus they will be

// printed as raw bytes.

TEST(PrintPointerTest, MemberFunctionPointer) {

  EXPECT_TRUE(HasPrefix(Print(&Foo::MyMethod),

                        Print(sizeof(&Foo::MyMethod)) + "-byte object "));

  EXPECT_TRUE(

      HasPrefix(Print(&Foo::MyVirtualMethod),

                Print(sizeof((&Foo::MyVirtualMethod))) + "-byte object "));

  int (Foo::*p)(char) = NULL;  // NOLINT

  EXPECT_TRUE(HasPrefix(Print(p),

                        Print(sizeof(p)) + "-byte object "));

}

// Tests printing C arrays.

// The difference between this and Print() is that it ensures that the

// argument is a reference to an array.

template <typename T, size_t N>

string PrintArrayHelper(T (&a)[N]) {

  return Print(a);

}

// One-dimensional array.

TEST(PrintArrayTest, OneDimensionalArray) {

  int a[5] = { 1, 2, 3, 4, 5 };

  EXPECT_EQ("{ 1, 2, 3, 4, 5 }", PrintArrayHelper(a));

}

// Two-dimensional array.

TEST(PrintArrayTest, TwoDimensionalArray) {

  int a[2][5] = {

    { 1, 2, 3, 4, 5 },