googlemock/test/gmock-matchers_test.cc

39 #include <string.h>
50 #include <string>
64 GTEST_API_ string JoinAsTuple(const Strings& fields);
157 using testing::internal::string;
192 string OfType(const string& type_name) {
202 string Describe(const Matcher<T>& m) {
210 string DescribeNegation(const Matcher<T>& m) {
218 string Explain(const MatcherType& m, const Value& x) {
367 // Tests that a C-string literal can be implicitly converted to a
368 // Matcher<string> or Matcher<const string&>.
370   Matcher<string> m1 = "hi";
374   Matcher<const string&> m2 = "hi";
379 // Tests that a string object can be implicitly converted to a
380 // Matcher<string> or Matcher<const string&>.
382   Matcher<string> m1 = string("hi");
386   Matcher<const string&> m2 = string("hi");
392 // Tests that a C-string literal can be implicitly converted to a
404 // Tests that a string object can be implicitly converted to a
407   Matcher<StringPiece> m1 = string("cats");
411   Matcher<const StringPiece&> m2 = string("cats");
770   EXPECT_THAT(string(), "");
976   Matcher<const string&> m1 = Lt("Hello");
1128   EXPECT_EQ(string(ss.str()), Describe(m));
1169 // Tests string comparison matchers.
1172   Matcher<const char*> m = StrEq(string("Hello"));
1177   Matcher<const string&> m2 = StrEq("Hello");
1183   Matcher<string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3");
1187   string str("01204500800");
1189   Matcher<string> m2 = StrEq(str);
1192   Matcher<string> m3 = StrEq(str);
1202   Matcher<string> m2 = StrNe(string("Hello"));
1213   Matcher<const char*> m = StrCaseEq(string("Hello"));
1219   Matcher<const string&> m2 = StrCaseEq("Hello");
1225   string str1("oabocdooeoo");
1226   string str2("OABOCDOOEOO");
1227   Matcher<const string&> m0 = StrCaseEq(str1);
1228   EXPECT_FALSE(m0.Matches(str2 + string(1, '\0')));
1231   Matcher<const string&> m1 = StrCaseEq(str1);
1236   Matcher<const string&> m2 = StrCaseEq(str1);
1240   Matcher<const string&> m3 = StrCaseEq(str1);
1246   EXPECT_FALSE(m3.Matches(string(str2, 0, 9)));
1250   Matcher<string> m = StrCaseEq("Hi");
1261   Matcher<string> m2 = StrCaseNe(string("Hello"));
1271 // Tests that HasSubstr() works for matching string-typed values.
1273   const Matcher<string> m1 = HasSubstr("foo");
1274   EXPECT_TRUE(m1.Matches(string("I love food.")));
1275   EXPECT_FALSE(m1.Matches(string("tofo")));
1277   const Matcher<const std::string&> m2 = HasSubstr("foo");
1278   EXPECT_TRUE(m2.Matches(std::string("I love food.")));
1279   EXPECT_FALSE(m2.Matches(std::string("tofo")));
1282 // Tests that HasSubstr() works for matching C-string-typed values.
1297   Matcher<string> m = HasSubstr("foo\n\"");
1302   Matcher<const pair<std::string, int>&> m = Key("foo");
1316   pair<int, std::string> p(25, "foo");
1362   Matcher<pair<int, const std::string> > m4 = Pair(25, "42");
1363   Matcher<pair<const std::string, int> > m5 = Pair("25", 42);
1367   Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42);
1420   pair<int, std::string> p(25, "foo");
1463   const Matcher<const char*> m1 = StartsWith(string(""));
1468   const Matcher<const string&> m2 = StartsWith("Hi");
1477   Matcher<const std::string> m = StartsWith("Hi");
1489   const Matcher<const string&> m2 = EndsWith(string("Hi"));
1498   Matcher<const std::string> m = EndsWith("Hi");
1510   const Matcher<const string&> m2 = MatchesRegex(new RE("a.*z"));
1517   Matcher<const std::string> m1 = MatchesRegex(string("Hi.*"));
1527   const Matcher<const char*> m1 = ContainsRegex(string("a.*z"));
1532   const Matcher<const string&> m2 = ContainsRegex(new RE("a.*z"));
1539   Matcher<const std::string> m1 = ContainsRegex("Hi.*");
1675 // Tests that HasSubstr() works for matching C-wide-string-typed values.
1866 // Tests that HasSubstr() works for matching C-wide-string-typed values.
2679 // with U == string and T == const char*
2680 // With ASSERT_THAT("hello"...) changed to ASSERT_THAT(string("hello") ... )
2683 // the code compiles but the converted string is bogus.
2688   Matcher<const string&> ends_with_ok = EndsWith("ok");
2690   const string bad = "bad";
3102   const string explanation = Explain(DoubleNear(2.1, 1e-10), 2.1 + 1.2e-10);
3247   const string prefix =
3340   const Matcher<const string*> m = Pointee(StartsWith("Hi"));
3342   EXPECT_EQ("", Explain(m, static_cast<const string*>(NULL)));
3588   const string& s() const { return s_; }
3590   void set_s(const string& new_s) { s_ = new_s; }
3596   string s_;
3802 string IntToStringFunction(int input) { return input == 1 ? "foo" : "bar"; }
3805   Matcher<int> matcher = ResultOf(&IntToStringFunction, Eq(string("foo")));
3871 const string& StringFunction(const string& input) { return input; }
3874   string s = "foo";
3875   string s2 = s;
3876   Matcher<const string&> matcher = ResultOf(&StringFunction, Ref(s));
3896       ResultOf(static_cast<string(*)(int dummy)>(NULL), Eq(string("foo"))),
3910 struct Functor : public ::std::unary_function<int, string> {
3917   Matcher<int> matcher = ResultOf(Functor(), Eq(string("foo")));
3940   EXPECT_TRUE(matcher_string.Matches("long string"));
4083   string text;
4087   text = string("\0", 1);
4118   map<string, int> container;
4293   map<int, std::string> my_map;
4297   map<int, std::string> test_map;
4301   const Matcher<const map<int, std::string>&> m = ContainerEq(my_map);
4347   std::string a1[][3] = {
4352   std::string a2[][3] = {
4357   const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2);
4383   list<string> words;
4387   EXPECT_THAT(words, WhenSortedBy(less<string>(),
4389   EXPECT_THAT(words, Not(WhenSortedBy(less<string>(),
4432   list<string> words;
4442     map<string, int> word_counts;
4766   const string a[5] = {"a", "b", "c", "d", "e"};
4940 static string EMString(int element, int matcher) {
4949   std::vector<string> v;
4958   string prefix =
5369   vector<string> another_vector;
5371   EXPECT_THAT(another_vector, Each(string("fee")));
5375   EXPECT_THAT(another_vector, Not(Each(string("fee"))));
5380   const char* bar = "a string";
5384   map<string, int> another_map;
5385   EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1)));
5387   EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1)));
5391   EXPECT_THAT(another_map, Not(Each(make_pair(string("fee"), 1))));
5392   EXPECT_THAT(another_map, Not(Each(make_pair(string("fum"), 1))));