Lines Matching defs:Action
158 // 2. a factory function that creates an Action object from a
163 // management as Action objects can now be copied like plain values.
720 class Action;
722 // An Action<R(Args...)> is a copyable and IMMUTABLE (except by assignment)
724 // R(Args...) is called. The implementation of Action<T> is just a
725 // std::shared_ptr to const ActionInterface<T>. Don't inherit from Action! You
727 // (including its current state), and an Action<F> object as a handle to it.
729 class Action<R(Args...)> {
733 // Adapter class to allow constructing Action from a legacy ActionInterface.
753 // Constructs a null Action. Needed for storing Action objects in
755 Action() {}
757 // Construct an Action from a specified callable.
758 // This cannot take std::function directly, because then Action would not be
765 Action(G&& fun) { // NOLINT
769 // Constructs an Action from its implementation.
770 explicit Action(ActionInterface<F>* impl)
773 // This constructor allows us to turn an Action<Func> object into an
774 // Action<F>, as long as F's arguments can be implicitly converted
777 Action(const Action<Func>& action) // NOLINT
785 // is that a const Action<F> means that it cannot be re-bound to
803 Action<F> action;
816 friend class Action;
869 operator Action<F>() const {
870 return Action<F>(new MonomorphicImpl<F>(impl_));
893 // Creates an Action from its implementation and returns it. The
894 // created Action object owns the implementation.
896 Action<F> MakeAction(ActionInterface<F>* impl) {
897 return Action<F>(impl);
946 operator Action<U(Args...)>() const { // NOLINT
961 // the input value (i.e. we are converting to Action).
1016 // made the Action<U()> conversion operator eagerly convert the R value to
1105 // Action, despite the fact that we are stateful and T may not be copyable.
1150 operator Action<F>() const {
1157 return Action<F>(new Impl<F>(ref_));
1192 operator Action<F>() const {
1199 return Action<F>(new Impl<F>(value_));
1257 operator Action<F>() const {
1258 return Action<F>();
1329 // Action<F> as long as f's type is compatible with F.
1364 operator Action<F>() const {
1378 return Action<F>(new Impl<F>(action_));
1401 const Action<OriginalFunction> action_;
1460 Action<R(internal::TupleElement<
1463 operator Action<R(Args...)>() const { // NOLINT
1464 Action<InnerSignature<R, Args...>> converted(inner_action);
1503 std::is_convertible<const FinalAction&, Action<R(Args...)>>::value,
1505 operator Action<R(Args...)>() const { // NOLINT
1533 // convertible to Action<void(const int&)>. This is perhaps less
1616 // Action.
1618 Action<void(InitialActionArgType<Args>...)>>,
1619 std::is_convertible<const Base&, Action<R(Args...)>>>::value,
1621 operator Action<R(Args...)>() const { // NOLINT
1626 Action<void(InitialActionArgType<Args>...)> initial_action;
1627 Action<R(Args...)> remaining_actions;
1741 operator Action<R(Args...)>() const { // NOLINT
1785 template <typename... Action>
1786 internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
1787 Action&&... action) {
1788 return internal::DoAllAction<typename std::decay<Action>::type...>(
1789 {}, std::forward<Action>(action)...);
2010 // Action ReturnArg<k>() returns the k-th argument of the mock function.
2016 // Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
2023 // Action SaveArgPointee<k>(pointer) saves the value pointed to
2030 // Action SetArgReferee<k>(value) assigns 'value' to the variable
2038 // Action SetArrayArgument<k>(first, last) copies the elements in
2049 // Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
2062 // Action Throw(exception) can be used in a mock function of any type
2089 // Builds an implementation of an Action<> for some particular signature, using
2097 // Allows each copy of the Action<> to get to the Impl.
2142 // Stores a default-constructed Impl as part of the Action<>'s
2145 ::testing::Action<F> MakeAction() {
2146 return ::testing::Action<F>(ActionImpl<F, Impl>());
2151 ::testing::Action<F> MakeAction(std::shared_ptr<Impl> impl) {
2152 return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl)));
2206 operator ::testing::Action<F>() const { \
2242 class name##Action { \
2244 explicit name##Action() noexcept {} \
2245 name##Action(const name##Action&) noexcept {} \
2247 operator ::testing::Action<F>() const { \
2259 inline name##Action name() GTEST_MUST_USE_RESULT_; \
2260 inline name##Action name() { return name##Action(); } \
2263 return_type name##Action::gmock_Impl::gmock_PerformImpl( \