Tránh phù hợp với .WillOnce nhiều lần trong Google Mock

Question

Tôi có một thiết lập đối tượng giả trông như thế này:

MyObject obj; 
EXPECT_CALL(obj, myFunction(_)) 
.WillOnce(Return(1)) 
.WillOnce(Return(1)) 
.WillOnce(Return(1)) 
.WillRepeatedly(Return(-1)); 

Có cách nào để không phải lặp lại .WillOnce(Return(1)) ba lần?

Answer 1

using testing::InSequence; 

MyObject obj; 

{ 
    InSequence s; 
    EXPECT_CALL(obj, myFunction(_)) 
     .Times(3) 
     .WillRepeatedly(Return(1)); 
    EXPECT_CALL(obj, myFunction(_)) 
     .WillRepeatedly(Return(-1)); 
} 

Answer 2

Tôi e rằng không có cách nào khác để định cấu hình hành vi này. Không thể tìm thấy một cách rõ ràng trong tài liệu ít nhất.

Mặc dù vậy, bạn có thể gặp vấn đề giới thiệu user defined matcher phù hợp, theo dõi số lượng cuộc gọi và ngưỡng bạn có thể cung cấp từ testcases của bạn thông qua các tham số mẫu (không thực sự biết cách tự động tạo ResultType:():

using ::testing::MakeMatcher; 
using ::testing::Matcher; 
using ::testing::MatcherInterface; 
using ::testing::MatchResultListener; 

template 
    < unsigned int CallThreshold 
    , typename ResultType 
    , ResultType LowerRetValue 
    , ResultType HigherRetValue 
    > 
class MyCountingReturnMatcher 
: public MatcherInterface<ResultType> 
{ 
public: 
    MyCountingReturnMatcher() 
    : callCount(0) 
    { 
    } 

    virtual bool MatchAndExplain 
     (ResultType n 
     , MatchResultListener* listener 
     ) const 
    { 
     ++callCount; 
     if(callCount <= CallThreshold) 
     { 
      return n == LowerRetValue; 
     } 

     return n == HigherRetValue; 
    } 

    virtual void DescribeTo(::std::ostream* os) const 
    { 
     if(callCount <= CallThreshold) 
     { 
      *os << "returned " << LowerRetValue; 
     } 
     else 
     { 
      *os << "returned " << HigherRetValue; 
     } 
    } 

    virtual void DescribeNegationTo(::std::ostream* os) const 
    { 
     *os << " didn't return expected value "; 
     if(callCount <= CallThreshold) 
     { 
      *os << "didn't return expected " << LowerRetValue 
       << " at call #" << callCount; 
     } 
     else 
     { 
      *os << "didn't return expected " << HigherRetValue 
       << " at call #" << callCount; 
     } 
    } 

private: 
    unsigned int callCount; 
}; 

template 
    < unsigned int CallThreshold 
    , typename ResultType 
    , ResultType LowerRetValue 
    , ResultType HigherRetValue 
    > 
inline Matcher<ResultType> MyCountingReturnMatcher() 
{ 
    return MakeMatcher 
       (new MyCountingReturnMatcher 
        < ResultType 
        , CallThreshold 
        , ResultType 
        , LowerRetValue 
        , HigherRetValue 
        >() 
       ); 
} 

Sử dụng sau đó để mong đợi một kết quả gọi chắc chắn tính:

EXPECT_CALL(blah,method) 
    .WillRepeatedly(MyCountingReturnMatcher<1000,int,1,-1>()) // Checks that method 
                  // returns 1000 times 1 
                  // but -1 on subsequent 
                  // calls. 

LƯU Ý
Tôi không kiểm tra mã này để hoạt động như dự định, nhưng nó sẽ hướng dẫn bạn đi đúng hướng.

Answer 3

Vì mục đích đầy đủ, có một tùy chọn chuẩn/đơn giản khác, mặc dù câu trả lời được chấp nhận có vẻ rõ ràng hơn trong trường hợp này.

EXPECT_CALL(obj, myFunction(_)).WillRepeatedly(Return(-1)); 
EXPECT_CALL(obj, myFunction(_)).Times(3).WillRepeatedly(Return(1)).RetiresOnSaturation(); 

này có thể hữu ích nếu bạn biết những gì bạn muốn trả lời/default cuối cùng của bạn là (-1), nhưng muốn muck với số lần nó được gọi là trước đó.