zjk/googletest
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Unfortunately, the svn repo is a bit out of date. This commit contains 8

Browse Source 
changes that haven't made it to svn. The descriptions of each change are listed
below.

- Fixes some python shebang lines.

- Add ElementsAreArray overloads to gmock. ElementsAreArray now makes a copy of
  its input elements before the conversion to a Matcher. ElementsAreArray can
  now take a vector as input. ElementsAreArray can now take an iterator pair as
  input.

- Templatize MatchAndExplain to allow independent string types for the matcher
  and matchee. I also templatized the ConstCharPointer version of
  MatchAndExplain to avoid calls with "char*" from using the new templated
  MatchAndExplain.

- Fixes the bug where the constructor of the return type of ElementsAre() saves
  a reference instead of a copy of the arguments.

- Extends ElementsAre() to accept arrays whose sizes aren't known.

- Switches gTest's internal FilePath class from testing::internal::String to
  std::string. testing::internal::String was introduced when gTest couldn't
  depend on std::string.  It's now deprecated.

- Switches gTest & gMock from using testing::internal::String objects to
  std::string. Some static methods of String are still in use.  We may be able
  to remove some but not all of them.  In particular, String::Format() should
  eventually be removed as it truncates the result at 4096 characters, often
  causing problems.
This commit is contained in:
jgm
2012-11-15 15:47:38 +00:00
parent 78bf6d5724
commit 87fdda2cf2
28 changed files with 533 additions and 1090 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/gtest_unittest.cc
+31 -328
View File
@@ -931,259 +931,16 @@ TEST(AssertHelperTest, AssertHelperIsSmall) {
EXPECT_LE(sizeof(testing::internal::AssertHelper), sizeof(void*));
}
// Tests the String class.
// Tests String's constructors.
TEST(StringTest, Constructors) {
// Default ctor.
String s1;
// We aren't using EXPECT_EQ(NULL, s1.c_str()) because comparing
// pointers with NULL isn't supported on all platforms.
EXPECT_EQ(0U, s1.length());
EXPECT_TRUE(NULL == s1.c_str());
// Implicitly constructs from a C-string.
String s2 = "Hi";
EXPECT_EQ(2U, s2.length());
EXPECT_STREQ("Hi", s2.c_str());
// Constructs from a C-string and a length.
String s3("hello", 3);
EXPECT_EQ(3U, s3.length());
EXPECT_STREQ("hel", s3.c_str());
// The empty String should be created when String is constructed with
// a NULL pointer and length 0.
EXPECT_EQ(0U, String(NULL, 0).length());
EXPECT_FALSE(String(NULL, 0).c_str() == NULL);
// Constructs a String that contains '\0'.
String s4("a\0bcd", 4);
EXPECT_EQ(4U, s4.length());
EXPECT_EQ('a', s4.c_str()[0]);
EXPECT_EQ('\0', s4.c_str()[1]);
EXPECT_EQ('b', s4.c_str()[2]);
EXPECT_EQ('c', s4.c_str()[3]);
// Copy ctor where the source is NULL.
const String null_str;
String s5 = null_str;
EXPECT_TRUE(s5.c_str() == NULL);
// Copy ctor where the source isn't NULL.
String s6 = s3;
EXPECT_EQ(3U, s6.length());
EXPECT_STREQ("hel", s6.c_str());
// Copy ctor where the source contains '\0'.
String s7 = s4;
EXPECT_EQ(4U, s7.length());
EXPECT_EQ('a', s7.c_str()[0]);
EXPECT_EQ('\0', s7.c_str()[1]);
EXPECT_EQ('b', s7.c_str()[2]);
EXPECT_EQ('c', s7.c_str()[3]);
}
TEST(StringTest, ConvertsFromStdString) {
// An empty std::string.
const std::string src1("");
const String dest1 = src1;
EXPECT_EQ(0U, dest1.length());
EXPECT_STREQ("", dest1.c_str());
// A normal std::string.
const std::string src2("Hi");
const String dest2 = src2;
EXPECT_EQ(2U, dest2.length());
EXPECT_STREQ("Hi", dest2.c_str());
// An std::string with an embedded NUL character.
const char src3[] = "a\0b";
const String dest3 = std::string(src3, sizeof(src3));
EXPECT_EQ(sizeof(src3), dest3.length());
EXPECT_EQ('a', dest3.c_str()[0]);
EXPECT_EQ('\0', dest3.c_str()[1]);
EXPECT_EQ('b', dest3.c_str()[2]);
}
TEST(StringTest, ConvertsToStdString) {
// An empty String.
const String src1("");
const std::string dest1 = src1;
EXPECT_EQ("", dest1);
// A normal String.
const String src2("Hi");
const std::string dest2 = src2;
EXPECT_EQ("Hi", dest2);
// A String containing a '\0'.
const String src3("x\0y", 3);
const std::string dest3 = src3;
EXPECT_EQ(std::string("x\0y", 3), dest3);
}
#if GTEST_HAS_GLOBAL_STRING
TEST(StringTest, ConvertsFromGlobalString) {
// An empty ::string.
const ::string src1("");
const String dest1 = src1;
EXPECT_EQ(0U, dest1.length());
EXPECT_STREQ("", dest1.c_str());
// A normal ::string.
const ::string src2("Hi");
const String dest2 = src2;
EXPECT_EQ(2U, dest2.length());
EXPECT_STREQ("Hi", dest2.c_str());
// An ::string with an embedded NUL character.
const char src3[] = "x\0y";
const String dest3 = ::string(src3, sizeof(src3));
EXPECT_EQ(sizeof(src3), dest3.length());
EXPECT_EQ('x', dest3.c_str()[0]);
EXPECT_EQ('\0', dest3.c_str()[1]);
EXPECT_EQ('y', dest3.c_str()[2]);
}
TEST(StringTest, ConvertsToGlobalString) {
// An empty String.
const String src1("");
const ::string dest1 = src1;
EXPECT_EQ("", dest1);
// A normal String.
const String src2("Hi");
const ::string dest2 = src2;
EXPECT_EQ("Hi", dest2);
const String src3("x\0y", 3);
const ::string dest3 = src3;
EXPECT_EQ(::string("x\0y", 3), dest3);
}
#endif // GTEST_HAS_GLOBAL_STRING
// Tests String::empty().
TEST(StringTest, Empty) {
EXPECT_TRUE(String("").empty());
EXPECT_FALSE(String().empty());
EXPECT_FALSE(String(NULL).empty());
EXPECT_FALSE(String("a").empty());
EXPECT_FALSE(String("\0", 1).empty());
}
// Tests String::Compare().
TEST(StringTest, Compare) {
// NULL vs NULL.
EXPECT_EQ(0, String().Compare(String()));
// NULL vs non-NULL.
EXPECT_EQ(-1, String().Compare(String("")));
// Non-NULL vs NULL.
EXPECT_EQ(1, String("").Compare(String()));
// The following covers non-NULL vs non-NULL.
// "" vs "".
EXPECT_EQ(0, String("").Compare(String("")));
// "" vs non-"".
EXPECT_EQ(-1, String("").Compare(String("\0", 1)));
EXPECT_EQ(-1, String("").Compare(" "));
// Non-"" vs "".
EXPECT_EQ(1, String("a").Compare(String("")));
// The following covers non-"" vs non-"".
// Same length and equal.
EXPECT_EQ(0, String("a").Compare(String("a")));
// Same length and different.
EXPECT_EQ(-1, String("a\0b", 3).Compare(String("a\0c", 3)));
EXPECT_EQ(1, String("b").Compare(String("a")));
// Different lengths.
EXPECT_EQ(-1, String("a").Compare(String("ab")));
EXPECT_EQ(-1, String("a").Compare(String("a\0", 2)));
EXPECT_EQ(1, String("abc").Compare(String("aacd")));
}
// Tests String::operator==().
TEST(StringTest, Equals) {
const String null(NULL);
EXPECT_TRUE(null == NULL); // NOLINT
EXPECT_FALSE(null == ""); // NOLINT
EXPECT_FALSE(null == "bar"); // NOLINT
const String empty("");
EXPECT_FALSE(empty == NULL); // NOLINT
EXPECT_TRUE(empty == ""); // NOLINT
EXPECT_FALSE(empty == "bar"); // NOLINT
const String foo("foo");
EXPECT_FALSE(foo == NULL); // NOLINT
EXPECT_FALSE(foo == ""); // NOLINT
EXPECT_FALSE(foo == "bar"); // NOLINT
EXPECT_TRUE(foo == "foo"); // NOLINT
const String bar("x\0y", 3);
EXPECT_NE(bar, "x");
}
// Tests String::operator!=().
TEST(StringTest, NotEquals) {
const String null(NULL);
EXPECT_FALSE(null != NULL); // NOLINT
EXPECT_TRUE(null != ""); // NOLINT
EXPECT_TRUE(null != "bar"); // NOLINT
const String empty("");
EXPECT_TRUE(empty != NULL); // NOLINT
EXPECT_FALSE(empty != ""); // NOLINT
EXPECT_TRUE(empty != "bar"); // NOLINT
const String foo("foo");
EXPECT_TRUE(foo != NULL); // NOLINT
EXPECT_TRUE(foo != ""); // NOLINT
EXPECT_TRUE(foo != "bar"); // NOLINT
EXPECT_FALSE(foo != "foo"); // NOLINT
const String bar("x\0y", 3);
EXPECT_NE(bar, "x");
}
// Tests String::length().
TEST(StringTest, Length) {
EXPECT_EQ(0U, String().length());
EXPECT_EQ(0U, String("").length());
EXPECT_EQ(2U, String("ab").length());
EXPECT_EQ(3U, String("a\0b", 3).length());
}
// Tests String::EndsWith().
TEST(StringTest, EndsWith) {
EXPECT_TRUE(String("foobar").EndsWith("bar"));
EXPECT_TRUE(String("foobar").EndsWith(""));
EXPECT_TRUE(String("").EndsWith(""));
EXPECT_FALSE(String("foobar").EndsWith("foo"));
EXPECT_FALSE(String("").EndsWith("foo"));
}
// Tests String::EndsWithCaseInsensitive().
TEST(StringTest, EndsWithCaseInsensitive) {
EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("BAR"));
EXPECT_TRUE(String("foobaR").EndsWithCaseInsensitive("bar"));
EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive(""));
EXPECT_TRUE(String("").EndsWithCaseInsensitive(""));
EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", "BAR"));
EXPECT_TRUE(String::EndsWithCaseInsensitive("foobaR", "bar"));
EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", ""));
EXPECT_TRUE(String::EndsWithCaseInsensitive("", ""));
EXPECT_FALSE(String("Foobar").EndsWithCaseInsensitive("foo"));
EXPECT_FALSE(String("foobar").EndsWithCaseInsensitive("Foo"));
EXPECT_FALSE(String("").EndsWithCaseInsensitive("foo"));
EXPECT_FALSE(String::EndsWithCaseInsensitive("Foobar", "foo"));
EXPECT_FALSE(String::EndsWithCaseInsensitive("foobar", "Foo"));
EXPECT_FALSE(String::EndsWithCaseInsensitive("", "foo"));
}
// C++Builder's preprocessor is buggy; it fails to expand macros that
@@ -1203,61 +960,6 @@ TEST(StringTest, CaseInsensitiveWideCStringEquals) {
EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar"));
}
// Tests that NULL can be assigned to a String.
TEST(StringTest, CanBeAssignedNULL) {
const String src(NULL);
String dest;
dest = src;
EXPECT_STREQ(NULL, dest.c_str());
}
// Tests that the empty string "" can be assigned to a String.
TEST(StringTest, CanBeAssignedEmpty) {
const String src("");
String dest;
dest = src;
EXPECT_STREQ("", dest.c_str());
}
// Tests that a non-empty string can be assigned to a String.
TEST(StringTest, CanBeAssignedNonEmpty) {
const String src("hello");
String dest;
dest = src;
EXPECT_EQ(5U, dest.length());
EXPECT_STREQ("hello", dest.c_str());
const String src2("x\0y", 3);
String dest2;
dest2 = src2;
EXPECT_EQ(3U, dest2.length());
EXPECT_EQ('x', dest2.c_str()[0]);
EXPECT_EQ('\0', dest2.c_str()[1]);
EXPECT_EQ('y', dest2.c_str()[2]);
}
// Tests that a String can be assigned to itself.
TEST(StringTest, CanBeAssignedSelf) {
String dest("hello");
// Use explicit function call notation here to suppress self-assign warning.
dest.operator=(dest);
EXPECT_STREQ("hello", dest.c_str());
}
// Sun Studio < 12 incorrectly rejects this code due to an overloading
// ambiguity.
#if !(defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
// Tests streaming a String.
TEST(StringTest, Streams) {
EXPECT_EQ(StreamableToString(String()), "(null)");
EXPECT_EQ(StreamableToString(String("")), "");
EXPECT_EQ(StreamableToString(String("a\0b", 3)), "a\\0b");
}
#endif
// Tests that String::Format() works.
TEST(StringTest, FormatWorks) {
// Normal case: the format spec is valid, the arguments match the
@@ -1269,19 +971,19 @@ TEST(StringTest, FormatWorks) {
const size_t kSize = sizeof(buffer);
memset(buffer, 'a', kSize - 1);
buffer[kSize - 1] = '\0';
EXPECT_STREQ(buffer, String::Format("%s", buffer).c_str());
EXPECT_EQ(buffer, String::Format("%s", buffer));
// The result needs to be 4096 characters, exceeding Format()'s limit.
EXPECT_STREQ("<formatting error or buffer exceeded>",
String::Format("x%s", buffer).c_str());
EXPECT_EQ("<formatting error or buffer exceeded>",
String::Format("x%s", buffer));
#if GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
// On Linux, invalid format spec should lead to an error message.
// In other environment (e.g. MSVC on Windows), String::Format() may
// simply ignore a bad format spec, so this assertion is run on
// Linux only.
EXPECT_STREQ("<formatting error or buffer exceeded>",
String::Format("%").c_str());
EXPECT_EQ("<formatting error or buffer exceeded>",
String::Format("%"));
#endif
}
@@ -1915,15 +1617,16 @@ static void SetEnv(const char* name, const char* value) {
// C++Builder's putenv only stores a pointer to its parameter; we have to
// ensure that the string remains valid as long as it might be needed.
// We use an std::map to do so.
static std::map<String, String*> added_env;
static std::map<std::string, std::string*> added_env;
// Because putenv stores a pointer to the string buffer, we can't delete the
// previous string (if present) until after it's replaced.
String *prev_env = NULL;
std::string *prev_env = NULL;
if (added_env.find(name) != added_env.end()) {
prev_env = added_env[name];
}
added_env[name] = new String((Message() << name << "=" << value).GetString());
added_env[name] = new std::string(
(Message() << name << "=" << value).GetString());
// The standard signature of putenv accepts a 'char*' argument. Other
// implementations, like C++Builder's, accept a 'const char*'.
@@ -3568,8 +3271,8 @@ TEST_F(NoFatalFailureTest, MessageIsStreamable) {
// Tests EqFailure(), used for implementing *EQ* assertions.
TEST(AssertionTest, EqFailure) {
const String foo_val("5"), bar_val("6");
const String msg1(
const std::string foo_val("5"), bar_val("6");
const std::string msg1(
EqFailure("foo", "bar", foo_val, bar_val, false)
.failure_message());
EXPECT_STREQ(
@@ -3579,7 +3282,7 @@ TEST(AssertionTest, EqFailure) {
"Which is: 5",
msg1.c_str());
const String msg2(
const std::string msg2(
EqFailure("foo", "6", foo_val, bar_val, false)
.failure_message());
EXPECT_STREQ(
@@ -3588,7 +3291,7 @@ TEST(AssertionTest, EqFailure) {
"Which is: 5",
msg2.c_str());
const String msg3(
const std::string msg3(
EqFailure("5", "bar", foo_val, bar_val, false)
.failure_message());
EXPECT_STREQ(
@@ -3597,16 +3300,16 @@ TEST(AssertionTest, EqFailure) {
"Expected: 5",
msg3.c_str());
const String msg4(
const std::string msg4(
EqFailure("5", "6", foo_val, bar_val, false).failure_message());
EXPECT_STREQ(
"Value of: 6\n"
"Expected: 5",
msg4.c_str());
const String msg5(
const std::string msg5(
EqFailure("foo", "bar",
String("\"x\""), String("\"y\""),
std::string("\"x\""), std::string("\"y\""),
true).failure_message());
EXPECT_STREQ(
"Value of: bar\n"
@@ -3618,7 +3321,7 @@ TEST(AssertionTest, EqFailure) {
// Tests AppendUserMessage(), used for implementing the *EQ* macros.
TEST(AssertionTest, AppendUserMessage) {
const String foo("foo");
const std::string foo("foo");
Message msg;
EXPECT_STREQ("foo",
@@ -4199,7 +3902,7 @@ TEST(AssertionSyntaxTest, WorksWithSwitch) {
#if GTEST_HAS_EXCEPTIONS
void ThrowAString() {
throw "String";
throw "std::string";
}
// Test that the exception assertion macros compile and work with const
@@ -5619,7 +5322,7 @@ class InitGoogleTestTest : public Test {
internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
#if GTEST_HAS_STREAM_REDIRECTION
const String captured_stdout = GetCapturedStdout();
const std::string captured_stdout = GetCapturedStdout();
#endif
// Verifies the flag values.
@@ -6891,7 +6594,7 @@ TEST(TestEventListenersTest, Append) {
// order.
class SequenceTestingListener : public EmptyTestEventListener {
public:
SequenceTestingListener(std::vector<String>* vector, const char* id)
SequenceTestingListener(std::vector<std::string>* vector, const char* id)
: vector_(vector), id_(id) {}
protected:
@@ -6914,20 +6617,20 @@ class SequenceTestingListener : public EmptyTestEventListener {
}
private:
String GetEventDescription(const char* method) {
std::string GetEventDescription(const char* method) {
Message message;
message << id_ << "." << method;
return message.GetString();
}
std::vector<String>* vector_;
std::vector<std::string>* vector_;
const char* const id_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener);
};
TEST(EventListenerTest, AppendKeepsOrder) {
std::vector<String> vec;
std::vector<std::string> vec;
TestEventListeners listeners;
listeners.Append(new SequenceTestingListener(&vec, "1st"));
listeners.Append(new SequenceTestingListener(&vec, "2nd"));
@@ -7313,7 +7016,7 @@ TEST(GTestReferenceToConstTest, Works) {
TestGTestReferenceToConst<const char&, char>();
TestGTestReferenceToConst<const int&, const int>();
TestGTestReferenceToConst<const double&, double>();
TestGTestReferenceToConst<const String&, const String&>();
TestGTestReferenceToConst<const std::string&, const std::string&>();
}
// Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant.