2015-08-27 11 views
5

Używam Google Mock do określenia warstwy kompatybilności z zewnętrznym API. W zewnętrznym interfejsie API istnieje wiele sposobów wykonywania niektórych czynności, dlatego chcę określić, że spełnione jest co najmniej jedno (lub dokładnie jedno) oczekiwanie na zestaw oczekiwań. W pseudokodowym, to, co chcę zrobić:Google mock - przynajmniej jedno z wielu oczekiwań

Expectation e1 = EXPECT_CALL(API, doFoo(...)); 
Expectation e2 = EXPECT_CALL(API, doFooAndBar(...)); 
EXPECT_ONE_OF(e1, e2); 
wrapper.foo(...); 

Czy można to zrobić za pomocą Google Mock?

+0

'EXPECT_CALL (API, doFoo (_)) razy (1).' Prace? –

+0

@ BЈовић To działa tak długo, jak 'wrapper.foo()' wywołuje 'doFoo()', ale chcę przetestować, aby przejść, nawet jeśli 'wrapper.foo()' nie wywołuje 'doFoo()', tak długo jak jak nazywa 'doFooAndBar()' zamiast. – nemetroid

Odpowiedz

1

Jest to możliwe, aby zrobić na dwa sposoby:

  1. z metod niestandardowych wykonawca - utworzyć klasę, z tymi samymi metodami. A następnie użyć Invoke() przekazać wezwanie do tego obiektu
  2. z wykorzystaniem częściowego połączenia zamówienie - tworzyć różne oczekiwania w różnych sekwencjach, jak wyjaśniono here

metodą zwyczaj wykonawca

coś takiego to:

struct MethodsTracker { 
    void doFoo(int) { 
    ++ n; 
    } 
    void doFooAndBar(int, int) { 
    ++ n; 
    } 
    int n; 
}; 

TEST_F(MyTest, CheckItInvokesAtLeastOne) { 
    MethodsTracker tracker; 
    Api obj(mock); 

    EXPECT_CALL(mock, doFoo(_)).Times(AnyNumber()).WillByDefault(Invoke(&tracker, &MethodsTracker::doFoo)); 
    EXPECT_CALL(mock, doFooAndBar(_,_)).Times(AnyNumber()).WillByDefault(Invoke(&tracker, &MethodsTracker::doFooAndBar)); 

    obj.executeCall(); 

    // at least one 
    EXPECT_GE(tracker.n, 1); 
} 

użyciu częściowego połączenia kolejność

TEST_F(MyTest, CheckItInvokesAtLeastOne) { 
     MethodsTracker tracker; 
     Api obj(mock); 

     Sequence s1, s2, s3, s4; 

     EXPECT_CALL(mock, doFoo(_)).InSequence(s1).Times(AtLeast(1)); 
     EXPECT_CALL(mock, doFooAndBar(_,_)).InSequence(s1).Times(AtLeast(0)); 

     EXPECT_CALL(mock, doFoo(_)).InSequence(s2).Times(AtLeast(0)); 
     EXPECT_CALL(mock, doFooAndBar(_,_)).InSequence(s2).Times(AtLeast(1)); 

     EXPECT_CALL(mock, doFooAndBar(_,_)).InSequence(s3).Times(AtLeast(0)); 
     EXPECT_CALL(mock, doFoo(_)).InSequence(s3).Times(AtLeast(1)); 

     EXPECT_CALL(mock, doFooAndBar(_,_)).InSequence(s4).Times(AtLeast(1)); 
     EXPECT_CALL(mock, doFoo(_)).InSequence(s4).Times(AtLeast(0)); 

     obj.executeCall(); 
} 
+0

Wywołanie częściowego zamówienia wygląda tak, jakby mogło szybko wymknąć się spod kontroli, ale użycie niestandardowego executora metod wydaje się odpowiednim rozwiązaniem. – nemetroid

Powiązane problemy