amop - BasicUsage.wiki

Introduction

By using ABI and template techniques, make AMOP different from other C++ Mock Object library. Here is the basic usage for this library. And please read the Unit-Test in the source for more details.

Details

```

include

include "../MockObject.h"

include

using namespace amop;

//------------------------------------------------------------------ class IInterface { public: virtual void SimpleFunction() = 0; virtual void SimpleFunctionWithParams(float, std::string, const char*) = 0;

virtual int SimpleFunctionWithParamsAndReturn(float, std::string, const char*) = 0;

virtual void SimpleFunctionWithAlotParams(float, int, float, int, std::string) = 0;

virtual int SimpleFunctionWithReturn() = 0;
virtual int& SimpleFunctionWithRefReturn() = 0;

virtual void SimpleConstFunction() const = 0;

virtual std::string ComplexFunction(const std::string& crs,
    std::string& rs, std::string s) = 0;

virtual std::string ComplexConstFunction(const std::string& crs,
    std::string& rs, std::string s) const = 0;

virtual void PolicyTestFunction(
    std::string& str
    , std::string* pointedStr
    , char* const buffer
    );


virtual ~IInterface(){}

};

//------------------------------------------------------------------ TEST(CreateMockObject) { TMockObject mock;

CHECK( (IInterface*)mock );

}

//------------------------------------------------------------------ TEST(MockObjectNotImplementedThrowSimpleFunction) { TMockObject mock;

CHECK((IInterface*)mock);

CHECK_THROW(((IInterface*)mock)->SimpleFunction(), TNotImplementedException);

}

//------------------------------------------------------------------ TEST(MockObjectNotImplementedThrowComplexFunction) { TMockObject mock;

CHECK((IInterface*)mock);

std::string crs, rs, s;

CHECK_THROW(
    ((IInterface*)mock)->ComplexFunction(crs, rs, s), 
    TNotImplementedException);

}

//mockSubscriber.method("receive").expects(once()).with( eq(message) ); //------------------------------------------------------------------ TEST(MockObjectMethodSimple) { TMockObject mock;

mock.Method(&IInterface::SimpleFunction);
mock.Method(&IInterface::SimpleFunctionWithAlotParams);

((IInterface*)mock)->SimpleFunction();
((IInterface*)mock)->SimpleFunctionWithAlotParams(0, 0, 0, 0, std::string());

}

//------------------------------------------------------------------ TEST(MockObjectMethodComplex) { TMockObject mock;

mock.Method(&IInterface::ComplexFunction)
    .Will("Test Result");
std::string crs, rs, s;

std::string result = 
    ((IInterface*)mock)->ComplexFunction(crs, rs, s);

CHECK_EQUAL("Test Result", result.c_str());

}

//------------------------------------------------------------------ TEST(MockObjectMethodSimpleWithReturn) { TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithReturn)
    .Will(22);
mock.Method(&IInterface::SimpleFunctionWithRefReturn)
    .Will(1262);

CHECK_EQUAL(22, ((IInterface*)mock)->SimpleFunctionWithReturn());
CHECK_EQUAL(1262, ((IInterface*)mock)->SimpleFunctionWithRefReturn());

}

//------------------------------------------------------------------ TEST(MockObjectMethodConstSimple) { TMockObject mock;

mock.Method(&IInterface::SimpleConstFunction);

((IInterface*)mock)->SimpleConstFunction();

}

struct SimpleException : public std::exception { int value; SimpleException(int v) : std::exception() , value(v){ } };

void ThisThrows(){ throw SimpleException(42); }

//------------------------------------------------------------------ TEST(MockObjectMethodSimpleWithThrow) { TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithReturn)
  .Throws(std::exception());

CHECK_THROW(((IInterface*)mock)->SimpleFunctionWithReturn(), std::exception );

mock.Verify();

}

//------------------------------------------------------------------ TEST(MockObjectMethodSimpleWithInheritedThrow) { TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithReturn)
  .Throws(SimpleException(22));

CHECK_THROW(((IInterface*)mock)->SimpleFunctionWithReturn(), std::exception);

mock.Verify();

}

//------------------------------------------------------------------ TEST(MockObjectMethodSimpleWithManyThrow) { TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithReturn)
  .Throws(SimpleException(22));
mock.Method(&IInterface::SimpleFunctionWithReturn)
  .Wills(42);
mock.Method(&IInterface::SimpleFunctionWithReturn)
  .Throws(SimpleException(142));

try{
  ((IInterface*)mock)->SimpleFunctionWithReturn();
  CHECK(false);
}catch(SimpleException & se){
  CHECK_EQUAL(22, se.value);
}
CHECK_EQUAL(42, ((IInterface*)mock)->SimpleFunctionWithReturn());
try{
  ((IInterface*)mock)->SimpleFunctionWithReturn();
  CHECK(false);
}catch(SimpleException & se){
  CHECK_EQUAL(142, se.value);
}

mock.Verify();

}

//------------------------------------------------------------------ TEST(MockObjectMethodConstComplex) { TMockObject mock;

mock.Method(&IInterface::ComplexConstFunction)
    .Will("Test Result");
std::string crs, rs, s;

std::string result = 
    ((IInterface*)mock)->ComplexConstFunction(crs, rs, s);

CHECK_EQUAL("Test Result", result.c_str());

}

//------------------------------------------------------------------ TEST(MockObjectMethodMultiWithReturn) { TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithReturn)
    .Wills(22).Wills(11);

CHECK_EQUAL(22, ((IInterface*)mock)->SimpleFunctionWithReturn());
CHECK_EQUAL(11, ((IInterface*)mock)->SimpleFunctionWithReturn());

}

//------------------------------------------------------------------ TEST(MockObjectMethodSimpleExpect) { TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithParams)
    .Expect<0>(21.0f)
    .Expect<1>("Hello World")
    .Expect<2>("SomeText");

((IInterface*)mock)->SimpleFunctionWithParams(21.0f, "Hello World", "SomeText");

}

//------------------------------------------------------------------ TEST(MockObjectMethodSimpleExpectPolicy) { TMockObject mock;

mock.Method(&IInterface::PolicyTestFunction)
    .Expect<0>("First")
    .Expect<1>(Policy::Pointer("Second"))
    .Expect<2>(Policy::Array("Third", strlen("Third") + 1) );

std::string first = "First";
std::string second = "Second";
char buf[] = "Third";

((IInterface*)mock)->PolicyTestFunction(first, &second, buf) ;

}

//------------------------------------------------------------------ TEST(MockObjectMethodSimpleExpectThrow) { TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithParams)
    .Expect<0>(21.0f)
    .Expect<1>("Hello World")
    .Expect<2>("SomeText");

CHECK_THROW( ((IInterface*)mock)->SimpleFunctionWithParams(2.0f, "Hllo World", "SomeTet")
    , TNotEqualException );

}

//------------------------------------------------------------------ TEST(MockObjectMethodMultipleExpect) { TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithParams)
    .Expects<0>(1.0f)       .Expects<0>(2.0f)           .Expects<0>(3.0f)
    .Expects<1>("Hello 1")  .Expects<1>("Hello 2")      .Expects<1>("Hello 3")
    .Expects<2>("SomeText1").Expects<2>("SomeText2")    .Expects<2>("SomeText3");

((IInterface*)mock)->SimpleFunctionWithParams(1.0f, "Hello 1", "SomeText1");
((IInterface*)mock)->SimpleFunctionWithParams(2.0f, "Hello 2", "SomeText2");
((IInterface*)mock)->SimpleFunctionWithParams(3.0f, "Hello 3", "SomeText3");

}

//------------------------------------------------------------------ TEST(MockObjectMethodMultipleExpectThrow) { TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithParams)
    .Expects<0>(1.0f)       .Expects<0>(2.0f)           .Expects<0>(3.0f)
    .Expects<1>("Hello 1")  .Expects<1>("Hello 2")      .Expects<1>("Hello 3")
    .Expects<2>("SomeText1").Expects<2>("SomeText2")    .Expects<2>("SomeText3");

CHECK_THROW( ((IInterface*)mock)->SimpleFunctionWithParams(2.0f, "Hllo 1", "SmeText1")
    , TNotEqualException );

}

//------------------------------------------------------------------ TEST(MockObjectMethodSimpleExpectAndReturn) { TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithParamsAndReturn)
    .Expect<0>(21.0f)
    .Expect<1>("Hello World")
    .Expect<2>("SomeText")
    .Will(2);

CHECK_EQUAL(2, 
    ((IInterface*)mock)->SimpleFunctionWithParamsAndReturn(21.0f, "Hello World", "SomeText") );

CHECK_THROW(
    ((IInterface*)mock)->SimpleFunctionWithParamsAndReturn(1.0f, "Heo World", "SoText")
    , TNotEqualException );

}

//------------------------------------------------------------------ TEST(MockObjectMethodRedirectFreeFunc) { static std::string firstRecv; static std::string secondRecv; static std::string thirdRecv;

struct Local
{
    static std::string HandleRedirect(const std::string& crs,
        std::string& rs, std::string s)
    {
        firstRecv = crs;
        secondRecv = rs;
        thirdRecv = s;

        rs = "CHANGED";

        return "RESULT";
    }
};

TMockObject<IInterface> mock;

mock.Method(&IInterface::ComplexFunction)
    .Redirect(&Local::HandleRedirect);

std::string second = "Second";

std::string result = 
    ((IInterface*)mock)->ComplexFunction("First", second, "Third");

CHECK_EQUAL("RESULT", result.c_str());

CHECK_EQUAL("First", firstRecv.c_str());
CHECK_EQUAL("Second", secondRecv.c_str());      
CHECK_EQUAL("Third",  thirdRecv.c_str());

CHECK_EQUAL("CHANGED", second.c_str());

}

//------------------------------------------------------------------ struct TestRedirectLocal { std::string HandleRedirect(const std::string& crs, std::string& rs, std::string s) { firstRecv = crs; secondRecv = rs; thirdRecv = s;

    rs = "CHANGED";

    return "RESULT";
}

std::string firstRecv;
std::string secondRecv;
std::string thirdRecv;

};

//------------------------------------------------------------------ TEST(MockObjectMethodRedirectMethod) {

TestRedirectLocal local;

TMockObject<IInterface> mock;

mock.Method(&IInterface::ComplexFunction)
    .Redirect(&local, &TestRedirectLocal::HandleRedirect);

std::string second = "Second";

std::string result = 
    ((IInterface*)mock)->ComplexFunction("First", second, "Third");

CHECK_EQUAL("RESULT", result.c_str());

CHECK_EQUAL("First", local.firstRecv.c_str());
CHECK_EQUAL("Second", local.secondRecv.c_str());        
CHECK_EQUAL("Third",  local.thirdRecv.c_str());

CHECK_EQUAL("CHANGED", second.c_str());

}

//------------------------------------------------------------------ TEST(MockObjectMethodSet) {
TestRedirectLocal local;

TMockObject<IInterface> mock;

mock.Method(&IInterface::ComplexFunction)
    .Set<1>("CHANGED")
    .Will("");        

std::string second = "Second";

std::string result = 
    ((IInterface*)mock)->ComplexFunction("First", second, "Third");

CHECK_EQUAL("CHANGED", second.c_str());

}

//------------------------------------------------------------------ TEST(MockObjectMethodSimpleSetPolicy) { TMockObject mock;

mock.Method(&IInterface::PolicyTestFunction)
    .Set<0>("First")
    .Set<1>(Policy::Pointer("Second"))
    .Set<2>(Policy::Array("Third", strlen("Third") + 1) );

std::string first;
std::string second;
char buf[sizeof("Third")];

((IInterface*)mock)->PolicyTestFunction(first, &second, buf) ;

CHECK_EQUAL( "First", first.c_str() );
CHECK_EQUAL( "Second", second.c_str()  );
CHECK( memcmp("Third", buf, sizeof("Third") )== 0  );

}

//------------------------------------------------------------------ TEST(MockObjectMethodSetMultiple) {
TestRedirectLocal local;

TMockObject<IInterface> mock;

mock.Method(&IInterface::ComplexFunction)
    .Sets<1>("C1").Sets<1>("C2").Sets<1>("C3")
    .Will("");        

std::string second = "Second";

((IInterface*)mock)->ComplexFunction("First", second, "Third");
CHECK_EQUAL("C1", second.c_str());  
((IInterface*)mock)->ComplexFunction("First", second, "Third");
CHECK_EQUAL("C2", second.c_str());  
((IInterface*)mock)->ComplexFunction("First", second, "Third");
CHECK_EQUAL("C3", second.c_str());

}

//------------------------------------------------------------------ TEST(MockObjectMethodAddCallCount) {
TMockObject mock;

mock.Method(&IInterface::ComplexFunction).Will(std::string());

std::string second = "Second";

((IInterface*)mock)->ComplexFunction("First", second, "Third");
((IInterface*)mock)->ComplexFunction("First", second, "Third");
((IInterface*)mock)->ComplexFunction("First", second, "Third");

CHECK_EQUAL(3u, mock.Method(&IInterface::ComplexFunction).Count());

}

//------------------------------------------------------------------ TEST(MockObjectMethodReset) {
TMockObject mock;

mock.Method(&IInterface::SimpleFunction);

mock.Clear();

CHECK_THROW(((IInterface*)mock)->SimpleFunction(), TNotImplementedException);

}

//------------------------------------------------------------------ TEST(MockObjectMethodDestructor) {
TMockObject mock;

mock.Method(Destructor());

delete ((IInterface*)mock);

}

//------------------------------------------------------------------ TEST(MockObjectMethodVerifyCallCount) {
TMockObject mock;

mock.Method(&IInterface::SimpleFunction)
    .Count(3);

((IInterface*)mock)->SimpleFunction();
((IInterface*)mock)->SimpleFunction();
((IInterface*)mock)->SimpleFunction();

// It will not throw
mock.Verify();

((IInterface*)mock)->SimpleFunction();
CHECK_THROW(mock.Verify(), TCallCountException);

}

//------------------------------------------------------------------ TEST(MockObjectMethodVerifyExpects) {
TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithParams)
    .Expects<0>(1.0f).Expects<0>(2.0f).Expects<0>(3.0f)
    .Expect<1>("")
    .Expect<2>("");


((IInterface*)mock)->SimpleFunctionWithParams(1.0f, "", "");
((IInterface*)mock)->SimpleFunctionWithParams(2.0f, "", "");
((IInterface*)mock)->SimpleFunctionWithParams(3.0f, "", "");

// It will not throw
mock.Verify();

((IInterface*)mock)->SimpleFunctionWithParams(4.0f, "", "");
CHECK_THROW(mock.Verify(), TCallCountException);

}

//------------------------------------------------------------------ TEST(MockObjectMethodWillsCallCountException) {
TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithReturn)
    .Wills(1)
    .Wills(2)
    .Wills(3);

((IInterface*)mock)->SimpleFunctionWithReturn();
((IInterface*)mock)->SimpleFunctionWithReturn();
((IInterface*)mock)->SimpleFunctionWithReturn();

CHECK_THROW(((IInterface*)mock)->SimpleFunctionWithReturn()
    , TCallCountException);

}

//------------------------------------------------------------------ TEST(MockObjectMethodWillsCallCountVerify) {
TMockObject mock;

mock.Method(&IInterface::SimpleFunctionWithReturn)
    .Wills(1)
    .Wills(2)
    .Wills(3);

CHECK_THROW(mock.Verify(), TCallCountException);

}

//------------------------------------------------------------------ class ISimple1 { public: virtual void SimpleFunction() = 0; virtual int SimpleFunctionWithReturn() = 0; virtual ~ISimple1(); };

//------------------------------------------------------------------ class ISimple2 { public: virtual void SimpleFunction() = 0; virtual int SimpleFunctionWithReturn() = 0; virtual ~ISimple2(); };

//------------------------------------------------------------------ TEST(TwoInterfaces_noneImplemented) { TMockObject mock1; TMockObject mock2;

CHECK_THROW(((ISimple1*)mock1)->SimpleFunction(), TNotImplementedException);
CHECK_THROW(((ISimple2*)mock2)->SimpleFunction(), TNotImplementedException);

CHECK_THROW(((ISimple1*)mock1)->SimpleFunctionWithReturn(), TNotImplementedException);
CHECK_THROW(((ISimple2*)mock2)->SimpleFunctionWithReturn(), TNotImplementedException);

}

//------------------------------------------------------------------ TEST(TwoInterfaces_oneSimpleImplemented) { TMockObject mock1; TMockObject mock2;

mock1.Method(&ISimple1::SimpleFunction);

((ISimple1*)mock1)->SimpleFunction();
CHECK_THROW(((ISimple2*)mock2)->SimpleFunction(), TNotImplementedException);

CHECK_THROW(((ISimple1*)mock1)->SimpleFunctionWithReturn(), TNotImplementedException);
CHECK_THROW(((ISimple2*)mock2)->SimpleFunctionWithReturn(), TNotImplementedException);

}

//------------------------------------------------------------------ TEST(TwoInterfaces_bothSimpleImplemented) { TMockObject mock1; TMockObject mock2;

mock1.Method(&ISimple1::SimpleFunction);
mock2.Method(&ISimple2::SimpleFunction);

((ISimple1*)mock1)->SimpleFunction();
((ISimple2*)mock2)->SimpleFunction();

CHECK_THROW(((ISimple1*)mock1)->SimpleFunctionWithReturn(), TNotImplementedException);
CHECK_THROW(((ISimple2*)mock2)->SimpleFunctionWithReturn(), TNotImplementedException);

}

//------------------------------------------------------------------ TEST(TwoInterfaces_oneReturnImplemented) { TMockObject mock1; TMockObject mock2;

int expected1 = 1;
mock1.Method(&ISimple1::SimpleFunctionWithReturn)
    .Will(expected1);


CHECK_THROW(((ISimple1*)mock1)->SimpleFunction(), TNotImplementedException);
CHECK_THROW(((ISimple2*)mock2)->SimpleFunction(), TNotImplementedException);

int got = ((ISimple1*)mock1)->SimpleFunctionWithReturn();
CHECK_EQUAL(expected1, got);
CHECK_THROW(((ISimple2*)mock2)->SimpleFunctionWithReturn(), TNotImplementedException);

}

//------------------------------------------------------------------ TEST(TwoInterfaces_bothReturnImplemented) { TMockObject mock1; TMockObject mock2;

int expected1 = 1;
int expected2 = 2;

mock1.Method(&ISimple1::SimpleFunctionWithReturn)
    .Will(expected1);
mock2.Method(&ISimple2::SimpleFunctionWithReturn)
    .Will(expected2);


CHECK_THROW(((ISimple1*)mock1)->SimpleFunction(), TNotImplementedException);
CHECK_THROW(((ISimple2*)mock2)->SimpleFunction(), TNotImplementedException);

int got;
got = ((ISimple1*)mock1)->SimpleFunctionWithReturn();
CHECK_EQUAL(expected1, got);
got = ((ISimple2*)mock2)->SimpleFunctionWithReturn();
CHECK_EQUAL(expected2, got);

} ```

Code

Archive

amop - BasicUsage.wiki

Introduction

Details

include

include "../MockObject.h"

include