Lines Matching refs:std
68 // Direct use with std types.
69 static_assert(std::is_base_of<std::false_type,
70 internal::negation<std::true_type>>::value,
73 static_assert(std::is_base_of<std::true_type,
74 internal::negation<std::false_type>>::value,
79 static_assert(std::is_base_of<
80 std::true_type,
81 internal::negation<std::integral_constant<int, 0>>>::value,
84 static_assert(std::is_base_of<
85 std::false_type,
86 internal::negation<std::integral_constant<int, 1>>>::value,
89 static_assert(std::is_base_of<
90 std::false_type,
91 internal::negation<std::integral_constant<int, -1>>>::value,
97 // distinct from std::false_type and std::true_type, and are distinct from other
101 // "std::conjunction should evaluate to a type that inherits from the first
104 struct MyFalse : std::integral_constant<int, 0> {};
107 struct MyTrue : std::integral_constant<int, -1> {};
111 static_assert(std::is_base_of<std::true_type, internal::conjunction<>>::value,
116 std::is_base_of<MyFalse<0>, internal::conjunction<MyFalse<0>>>::value,
120 std::is_base_of<MyTrue<0>, internal::conjunction<MyTrue<0>>>::value, "");
124 std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
129 std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
137 std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
143 std::is_base_of<MyTrue<2>, internal::conjunction<MyTrue<0>, MyTrue<1>,
151 std::is_base_of<std::false_type, internal::disjunction<>>::value, "");
155 std::is_base_of<MyFalse<0>, internal::disjunction<MyFalse<0>>>::value,
159 std::is_base_of<MyTrue<0>, internal::disjunction<MyTrue<0>>>::value, "");
163 std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
168 std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
176 std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
182 std::is_base_of<MyFalse<2>, internal::disjunction<MyFalse<0>, MyFalse<1>,
191 std::string operator()(int) && { return ""; };
207 // void. Otherwise it is std::string (which is also treated as allowed for a
211 static_assert(!internal::is_callable_r<std::string, C&, int>::value, "");
214 static_assert(internal::is_callable_r<std::string, C, int>::value, "");
219 static_assert(!internal::is_callable_r<void, C, std::string>::value, "");
232 static_assert(!std::is_move_constructible_v<NonMoveable>);
336 EXPECT_EQ("", BuiltInDefaultValue<::std::string>::Get());
342 EXPECT_TRUE(BuiltInDefaultValue<::std::string>::Exists());
348 EXPECT_EQ("", BuiltInDefaultValue<const std::string>::Get());
448 EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
449 EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr);
450 DefaultValue<std::unique_ptr<int>>::SetFactory(
451 [] { return std::unique_ptr<int>(new int(42)); });
452 EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
453 std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
518 int Perform(const std::tuple<bool, int>& args) override {
519 return std::get<0>(args) ? std::get<1>(args) : 0;
535 // std::tuple<bool, int>, and so on.
536 EXPECT_EQ(5, action.Perform(std::make_tuple(true, 5)));
549 EXPECT_EQ(5, action.Perform(std::make_tuple(true, 5)));
550 EXPECT_EQ(0, action.Perform(std::make_tuple(false, 1)));
559 EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
560 EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 1)));
563 EXPECT_EQ(5, a2.Perform(std::make_tuple(true, 5)));
564 EXPECT_EQ(0, a2.Perform(std::make_tuple(false, 1)));
569 EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
570 EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 1)));
573 EXPECT_EQ(5, a2.Perform(std::make_tuple(true, 5)));
574 EXPECT_EQ(0, a2.Perform(std::make_tuple(false, 1)));
582 bool Perform(const std::tuple<int>& arg) override {
583 return std::get<0>(arg) != 0;
590 EXPECT_EQ(1, a2.Perform(std::make_tuple('a')));
591 EXPECT_EQ(0, a2.Perform(std::make_tuple('\0')));
605 return std::get<1>(args);
621 Result Perform(const std::tuple<>&) const {
642 EXPECT_EQ(5, a1.Perform(std::make_tuple(false, 5, 2.0)));
649 EXPECT_EQ(0, a1.Perform(std::make_tuple()));
652 EXPECT_TRUE(a2.Perform(std::make_tuple()) == nullptr);
659 return ret.Perform(std::make_tuple(1));
665 EXPECT_EQ(1, ret.Perform(std::make_tuple()));
668 EXPECT_EQ(-5, ret.Perform(std::make_tuple()));
674 EXPECT_STREQ("Hello", a1.Perform(std::make_tuple()));
676 Action<std::string()> a2 = Return("world");
677 EXPECT_EQ("world", a2.Perform(std::make_tuple()));
681 // reference-like wrapper for decltype(x), as when x is a std::string and the
682 // mock function returns std::string_view.
684 // A reference wrapper for std::vector<int>, implicitly convertible from it.
686 const std::vector<int>* v;
687 Result(const std::vector<int>& vec) : v(&vec) {} // NOLINT
700 .WillOnce(Return(std::vector<int>{17, 19, 23}))
701 .WillRepeatedly(Return(std::vector<int>{29, 31, 37}));
743 // std::reference_wrapper). This should work for both WillOnce and
747 using U = std::reference_wrapper<const int>;
749 static_assert(std::is_convertible<const R&, U>::value, "");
750 static_assert(!std::is_convertible<R, U>::value, "");
764 // Set up a type that is implicitly convertible from std::string&, but not
765 // std::string&& or `const std::string&`.
767 // Avoid asserting about conversion from std::string on MSVC, which seems to
768 // implement std::is_convertible incorrectly in this case.
770 S(std::string&) {} // NOLINT
773 static_assert(std::is_convertible<std::string&, S>::value, "");
775 static_assert(!std::is_convertible<std::string&&, S>::value, "");
777 static_assert(!std::is_convertible<const std::string&, S>::value, "");
779 // It shouldn't be possible to use the result of Return(std::string) in a
784 using RA = decltype(Return(std::string()));
786 static_assert(!std::is_convertible<RA, Action<S()>>::value, "");
788 static_assert(!std::is_convertible<RA, OnceAction<S()>>::value, "");
795 MockFunction<std::unique_ptr<int>()> mock;
798 .WillOnce(Return(std::unique_ptr<int>(new int(17))));
805 static_assert(!std::is_convertible<decltype(Return(std::unique_ptr<int>())),
806 Action<std::unique_ptr<int>()>>::value,
824 EXPECT_EQ(&base, ret.Perform(std::make_tuple()));
827 EXPECT_EQ(&derived, ret.Perform(std::make_tuple()));
856 action.Perform(std::tuple<>());
864 EXPECT_TRUE(a1.Perform(std::make_tuple()) == nullptr);
867 EXPECT_TRUE(a2.Perform(std::make_tuple(true)) == nullptr);
873 const Action<std::unique_ptr<const int>()> a1 = ReturnNull();
874 EXPECT_TRUE(a1.Perform(std::make_tuple()) == nullptr);
876 const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull();
877 EXPECT_TRUE(a2.Perform(std::make_tuple("foo")) == nullptr);
885 EXPECT_EQ(&n, &ret.Perform(std::make_tuple(true)));
893 EXPECT_EQ(&base, &a.Perform(std::make_tuple()));
896 EXPECT_EQ(&derived, &a.Perform(std::make_tuple()));
899 template <typename T, typename = decltype(ReturnRef(std::declval<T&&>()))>
910 std::string non_scalar_value("ABC");
916 const std::string const_non_scalar_value("CBA");
925 auto non_scalar_value = []() -> std::string { return "ABC"; };
932 auto const_non_scalar_value = []() -> const std::string { return "CBA"; };
941 EXPECT_NE(&n, &ret.Perform(std::make_tuple()));
942 EXPECT_EQ(42, ret.Perform(std::make_tuple()));
945 EXPECT_NE(&n, &ret.Perform(std::make_tuple()));
946 EXPECT_EQ(42, ret.Perform(std::make_tuple()));
954 EXPECT_NE(&base, &a.Perform(std::make_tuple()));
957 EXPECT_NE(&derived, &a.Perform(std::make_tuple()));
964 EXPECT_EQ(1, ret.Perform(std::make_tuple()));
965 EXPECT_EQ(2, ret.Perform(std::make_tuple()));
966 EXPECT_EQ(3, ret.Perform(std::make_tuple()));
967 EXPECT_EQ(1, ret.Perform(std::make_tuple()));
968 EXPECT_EQ(2, ret.Perform(std::make_tuple()));
969 EXPECT_EQ(3, ret.Perform(std::make_tuple()));
974 std::vector<double> v = {4.4, 5.5, 6.6};
977 EXPECT_EQ(4.4, ret.Perform(std::make_tuple()));
978 EXPECT_EQ(5.5, ret.Perform(std::make_tuple()));
979 EXPECT_EQ(6.6, ret.Perform(std::make_tuple()));
980 EXPECT_EQ(4.4, ret.Perform(std::make_tuple()));
981 EXPECT_EQ(5.5, ret.Perform(std::make_tuple()));
982 EXPECT_EQ(6.6, ret.Perform(std::make_tuple()));
993 MOCK_METHOD0(MakeUnique, std::unique_ptr<int>());
994 MOCK_METHOD0(MakeUniqueBase, std::unique_ptr<Base>());
995 MOCK_METHOD0(MakeVectorUnique, std::vector<std::unique_ptr<int>>());
996 MOCK_METHOD1(TakeUnique, int(std::unique_ptr<int>));
998 int(const std::unique_ptr<int>&, std::unique_ptr<int>));
1078 a.Perform(std::make_tuple(true, &n, &ch));
1085 a.Perform(std::make_tuple(true, &n, &ch));
1092 typedef void MyFunction(std::string*, const char**);
1094 std::string str;
1096 a.Perform(std::make_tuple(&str, &ptr));
1102 a.Perform(std::make_tuple(&str, &ptr));
1111 a.Perform(std::make_tuple(&ptr));
1116 typedef void MyStringFunction(std::wstring*);
1118 std::wstring str = L"";
1119 a2.Perform(std::make_tuple(&str));
1127 typedef void MyFunction(bool, std::string*, const char**);
1130 std::string str;
1132 a.Perform(std::make_tuple(true, &str, &ptr));
1140 a.Perform(std::make_tuple(true, &str, &ptr));
1150 a.Perform(std::make_tuple(true, &ptr));
1155 typedef void MyStringFunction(bool, std::wstring*);
1159 std::wstring str;
1160 a2.Perform(std::make_tuple(true, &str));
1173 a.Perform(std::make_tuple(true, &n, &ch));
1180 a.Perform(std::make_tuple(true, &n, &ch));
1230 EXPECT_EQ(1, a.Perform(std::make_tuple(2)));
1234 EXPECT_EQ(1, a2.Perform(std::make_tuple(2, 3.5)));
1239 a3.Perform(std::make_tuple(1));
1247 EXPECT_EQ(2, a.Perform(std::make_tuple()));
1252 EXPECT_EQ(2, a2.Perform(std::make_tuple(3, 3.5, 'a')));
1257 a3.Perform(std::make_tuple());
1266 EXPECT_EQ(123, a.Perform(std::make_tuple(true, 'a')));
1272 a.Perform(std::make_tuple(1));
1285 a.Perform(std::make_tuple());
1300 a.Perform(std::make_tuple(2));
1307 a.Perform(std::make_tuple(0));
1312 ::std::string x;
1314 a.Perform(std::make_tuple());
1321 a.Perform(std::make_tuple(0));
1482 EXPECT_TRUE(a.Perform(std::make_tuple(1.5, -1)));
1483 EXPECT_FALSE(a.Perform(std::make_tuple(1.5, 1)));
1491 EXPECT_EQ(s + 2, a.Perform(std::make_tuple(CharPtr(s), 0.5, Short(2))));
1495 std::string operator()() const { return {}; }
1497 std::string operator()(const char* a, I... i) const {
1504 Action<std::string(const char*, const char*, const char*, const char*)> a =
1507 a.Perform(std::make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
1514 int Perform(const std::tuple<int, int>& args) override {
1515 return std::get<0>(args) - std::get<1>(args);
1520 Action<int(const std::string&, int, int)> a =
1522 std::tuple<std::string, int, int> dummy =
1523 std::make_tuple(std::string("hi"), 2, 10);
1531 EXPECT_EQ(123, a.Perform(std::make_tuple(100, Char(20), Short(3))));
1538 EXPECT_EQ(4, a.Perform(std::make_tuple(false, 1, 10)));
1546 EXPECT_EQ(s + 2, a.Perform(std::make_tuple(Short(2), CharPtr(s))));
1554 a.Perform(std::make_tuple(Short(100), Char(20), 5.6, Char(3))));
1561 a.Perform(std::make_tuple(1.5, 'a', 3));
1568 const int& res = aa.Perform(std::forward_as_tuple(i, nullptr));
1609 EXPECT_EQ(-5, a.Perform(std::make_tuple()));
1616 EXPECT_EQ(&x, a.Perform(std::make_tuple()));
1622 EXPECT_DOUBLE_EQ(5.0, a.Perform(std::make_tuple()));
1632 const std::string s1 = "Hi";
1633 const std::string s2 = "Hello";
1636 const std::string& r1 = ref_wrapper;
1641 const std::string& r2 = ref_wrapper;
1647 const std::string& r3 = ref_wrapper;
1705 ::std::stringstream expected, actual;
1719 UnaryConstructorClass* c = a.Perform(std::make_tuple());
1727 UnaryConstructorClass* c = a.Perform(std::make_tuple(false, 5));
1735 const UnaryConstructorClass* c = a.Perform(std::make_tuple());
1753 TenArgConstructorClass* c = a.Perform(std::make_tuple());
1758 std::unique_ptr<int> UniquePtrSource() {
1759 return std::unique_ptr<int>(new int(19));
1762 std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
1763 std::vector<std::unique_ptr<int>> out;
1770 std::unique_ptr<int> i(new int(19));
1771 EXPECT_CALL(mock, MakeUnique()).WillOnce(Return(ByMove(std::move(i))));
1776 .WillOnce(Return(ByMove(std::unique_ptr<Derived>(d))));
1778 std::unique_ptr<int> result1 = mock.MakeUnique();
1781 std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
1786 std::unique_ptr<Base> result2 = mock.MakeUniqueBase();
1793 std::unique_ptr<int> i(new int(19));
1798 Return(ByMove(std::move(i)))));
1800 std::unique_ptr<int> result1 = mock.MakeUnique();
1808 DefaultValue<std::unique_ptr<int>>::SetFactory(
1809 [] { return std::unique_ptr<int>(new int(42)); });
1815 std::unique_ptr<int> result1 = mock.MakeUnique();
1817 std::unique_ptr<int> result2 = mock.MakeUnique();
1821 std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
1829 auto make = [](int i) { return std::unique_ptr<int>(new int(i)); };
1831 EXPECT_CALL(mock, TakeUnique(_)).WillRepeatedly([](std::unique_ptr<int> i) {
1836 // .WillRepeatedly(DoAll(Invoke([](std::unique_ptr<int> j) {}),
1854 .WillOnce([](const std::unique_ptr<int>& i, std::unique_ptr<int> j) {
1860 std::unique_ptr<int> saved;
1861 EXPECT_CALL(mock, TakeUnique(_)).WillOnce([&saved](std::unique_ptr<int> i) {
1862 saved = std::move(i);
2042 // Tests for std::function based action.
2051 int Deref(std::unique_ptr<int> ptr) { return *ptr; }
2060 std::unique_ptr<int> UniqueInt(int i) {
2061 return std::unique_ptr<int>(new int(i));
2067 EXPECT_EQ(6, a.Perform(std::forward_as_tuple(x, y, &z)));
2071 Action<int(std::unique_ptr<int>)> a1 = &Deref;
2072 EXPECT_EQ(7, a1.Perform(std::make_tuple(UniqueInt(7))));
2077 EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
2078 EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 5)));
2080 std::unique_ptr<int> saved;
2081 Action<void(std::unique_ptr<int>)> a2 = [&saved](std::unique_ptr<int> p) {
2082 saved = std::move(p);
2084 a2.Perform(std::make_tuple(UniqueInt(5)));
2090 EXPECT_EQ(2, ai.Perform(std::make_tuple(1)));
2092 EXPECT_EQ(3.0, ad.Perform(std::make_tuple(1.5)));
2099 EXPECT_EQ(1, a1.Perform(std::make_tuple(42)));
2100 EXPECT_EQ(0, a2.Perform(std::make_tuple(42)));
2103 const Action<bool(std::string)> s1 = [](std::string s) { return !s.empty(); };
2105 EXPECT_EQ(0, s2.Perform(std::make_tuple("")));
2106 EXPECT_EQ(1, s2.Perform(std::make_tuple("hello")));
2109 const Action<bool(std::string)> x1 = [](Unused) { return 42; };
2110 const Action<bool(std::string)> x2 = [] { return 42; };
2111 EXPECT_TRUE(x1.Perform(std::make_tuple("hello")));
2112 EXPECT_TRUE(x2.Perform(std::make_tuple("hello")));
2115 std::function<int()> f = [] { return 7; };
2118 EXPECT_EQ(7, d.Perform(std::make_tuple(1)));
2129 std::tuple<int, double, double> dummy = std::make_tuple(3, 7.3, 9.44);
2135 Action<int(std::unique_ptr<int>)> a = Return(1);
2136 EXPECT_EQ(1, a.Perform(std::make_tuple(nullptr)));
2139 EXPECT_EQ(7, a.Perform(std::make_tuple(nullptr)));
2141 Action<void(std::unique_ptr<int>, int*)> a2 = testing::SetArgPointee<1>(3);
2143 a2.Perform(std::make_tuple(nullptr, &x));
2147 ACTION(ReturnArity) { return std::tuple_size<args_type>::value; }
2151 1, testing::Action<int(int)>(ReturnArity()).Perform(std::make_tuple(0)));
2156 .Perform(std::make_tuple(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)));
2162 .Perform(std::make_tuple(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,