C++ 使用boost:：shared_ptr和AMOP进行模拟

我正试着用它来写模拟。我正在使用VisualStudio2008

我有这个接口类：

struct Interface {
   virtual void Activate() = 0;
};

另一个类接收指向此

接口的指针，如下所示：

struct UserOfInterface {
   void execute(Interface* iface) {
      iface->Activate();
   }
};

amop::TMockObject<Interface> mock;
mock.Method(&Interface::Activate).Count(1);

UserOfInterface user;
user.execute((Interface*)mock);

mock.Verifiy();

因此，我尝试编写如下测试代码：

struct UserOfInterface {
   void execute(Interface* iface) {
      iface->Activate();
   }
};

amop::TMockObject<Interface> mock;
mock.Method(&Interface::Activate).Count(1);

UserOfInterface user;
user.execute((Interface*)mock);

mock.Verifiy();

amop:：TMockObject mock；
mock.Method（&接口：：Activate）.Count（1）；
接口用户的用户；
执行（（接口*）模拟）；
mock.verify（）；

它起作用了！到目前为止还不错，但我真正想要的是execute（）方法中的boost:：shared_ptr，所以我写了以下内容：

struct UserOfInterface {
   void execute(boost::shared_ptr<Interface> iface) {
      iface->Activate();
   }
};

struct userof接口{
无效执行（boost:：shared_ptr iface）{
iface->Activate（）；
}
};

测试代码现在应该是怎样的？我试过一些东西，比如：

amop::TMockObject<Interface> mock;
mock.Method(&Interface::Activate).Count(1);

UserOfInterface user;
boost::shared_ptr<Interface> mockAsPtr((Interface*)mock);
user.execute(mockAsPtr);

mock.Verifiy();

amop:：TMockObject mock；
mock.Method（&接口：：Activate）.Count（1）；
接口用户的用户；
boost:：sharedptrmockasptr（（接口*）mock）；
user.execute（mockAsPtr）；
mock.verify（）；

它会编译，但显然会崩溃，因为在作用域的末尾，变量“mock”会被双重销毁（因为堆栈变量“mock”和共享的\u ptr）

我还尝试在堆上创建“mock”变量：

amop::TMockObject<Interface>* mock(new amop::TMockObject<Interface>);
mock->Method(&Interface::Activate).Count(1);

UserOfInterface user;
boost::shared_ptr<Interface> mockAsPtr((Interface*)*mock);
user.execute(mockAsPtr);

mock->Verifiy();

amop:：TMockObject*mock（新的amop:：TMockObject）；
模拟->方法（&接口：：激活）。计数（1）；
接口用户的用户；
boost:：sharedptrmockasptr（（接口*）*mock）；
user.execute（mockAsPtr）；
模拟->验证（）；

但它不起作用，不知何故它进入了一个无限循环，在我遇到boost问题之前，当共享的ptr试图删除该对象时，我没有找到模拟对象的析构函数

有人成功使用boost:：shared_ptr吗？
您可能想尝试使用更明确的强制转换。我不确定这是否有效，但试试看

// Get the mock generator
boost::shared_ptr< amop::TMockObject<Interface> > mock
    = boost::make_shared< amop::TMockObject<Interface> >;
// Get the mocked interface
boost::shared_ptr<Interface> imock = boost::dynamic_pointer_cast<Interface>(mock);

// Setup mock usage expectations
mock->Method(&Interface::Activate).Count(1);

// Run the test
UserOfInterface user;
user.execute(imock);

// Verify the expectations were met
mock->Verifiy();

//获取模拟生成器
boost:：shared_ptrmock
=boost:：使_共享；
//获取模拟接口
boost:：shared\u ptr imock=boost:：dynamic\u pointer\u cast（mock）；
//设置模拟使用预期
模拟->方法（&接口：：激活）。计数（1）；
//运行测试
接口用户的用户；
user.execute（imock）；
//验证是否满足预期
模拟->验证（）；
您可能希望尝试使用更明确的强制转换。我不确定这是否有效，但试试看

// Get the mock generator
boost::shared_ptr< amop::TMockObject<Interface> > mock
    = boost::make_shared< amop::TMockObject<Interface> >;
// Get the mocked interface
boost::shared_ptr<Interface> imock = boost::dynamic_pointer_cast<Interface>(mock);

// Setup mock usage expectations
mock->Method(&Interface::Activate).Count(1);

// Run the test
UserOfInterface user;
user.execute(imock);

// Verify the expectations were met
mock->Verifiy();

//获取模拟生成器
boost:：shared_ptrmock
=boost:：使_共享；
//获取模拟接口
boost:：shared\u ptr imock=boost:：dynamic\u pointer\u cast（mock）；
//设置模拟使用预期
模拟->方法（&接口：：激活）。计数（1）；
//运行测试
接口用户的用户；
user.execute（imock）；
//验证是否满足预期
模拟->验证（）；
好吧，我从来没有使用过amop，但这种增强模式可能会有所帮助

要创建boost shared_ptr，您还可以使用

boost::shared_ptr<Interface> mock(new amop::TMockObject<Interface>());

嗯，我从未使用过amop，但也许这种升压模式会有所帮助

要创建boost shared_ptr，您还可以使用

boost::shared_ptr<Interface> mock(new amop::TMockObject<Interface>());

您可以为共享函数提供一个自定义函子，当引用计数变为零时，将调用该函子而不是删除该函子

然后代码将如下所示（我没有尝试编译它）：

struct NoOpDel
{
void运算符（）（void*）{}
}
amop:：tmockobjectmock；
mock.Method（&接口：：Activate）.Count（1）；
接口用户的用户；
boost:：shared_ptr imock（（接口*）mock，NoOpDel（））
user.execute（imock）；
mock.Verify（）；

有关更多详细信息，请参阅，您对此构造函数感兴趣：

template<class Y, class D> shared_ptr(Y * p, D d);

模板共享（Y*p，D）；
您可以为共享\u ptr提供一个自定义functor，当引用计数变为零时，将调用该functor而不是delete

然后代码将如下所示（我没有尝试编译它）：

struct NoOpDel
{
void运算符（）（void*）{}
}
amop:：tmockobjectmock；
mock.Method（&接口：：Activate）.Count（1）；
接口用户的用户；
boost:：shared_ptr imock（（接口*）mock，NoOpDel（））
user.execute（imock）；
mock.Verify（）；

有关更多详细信息，请参阅，您对此构造函数感兴趣：

template<class Y, class D> shared_ptr(Y * p, D d);

模板共享（Y*p，D）；
免责声明：我是《河马》的作者

使用HippoMocks，您可以指定希望在测试结束时调用析构函数。它还会在测试结束时隐式验证您的期望。这样，它甚至可以防止堆上的一个丢失的共享ptr被您忘记删除，或者在您不使用共享ptr的情况下，一个不拥有所有权或忘记删除指针的类。
免责声明：我是HippoMocks的作者

使用HippoMocks，您可以指定希望在测试结束时调用析构函数。它还会在测试结束时隐式验证您的期望。这样，它甚至可以防止堆上的一个丢失的共享\u ptr被您忘记删除，或者在您不使用共享\u ptr的情况下，一个不拥有所有权或忘记删除指针的类。
有一种方法可以将共享\u ptr与amop一起使用

struct Interface {
   virtual ~Interface() {}
   virtual void Activate() = 0;
};

TEST(MockObjectMethodDestructor)
{  
    TMockObject<Interface> mock;

    mock.Method(Destructor());

    boost::shared_ptr<Interface> ptr((IInterface*)mock);

    ptr.reset();
}

struct接口{
虚拟~Interface（）{}
虚空激活（）=0；
};
测试（MockObjectMethodDestructor）
{  
TMockObject模拟；
方法（析构函数（））；
boost：：共享的ptr（（IInterface*）mock）；
ptr.reset（）；
}
有一种方法可以将共享ptr与amop一起使用

struct Interface {
   virtual ~Interface() {}
   virtual void Activate() = 0;
};

TEST(MockObjectMethodDestructor)
{  
    TMockObject<Interface> mock;

    mock.Method(Destructor());

    boost::shared_ptr<Interface> ptr((IInterface*)mock);

    ptr.reset();
}

struct接口{
虚拟~Interface（）{}
虚空激活（）=0；
};
测试（MockObjectMethodDestructor）
{  
TMockObject模拟；
方法（析构函数（））；
boost：：共享的ptr（（IInterface*）mock）；
ptr.reset（）；
}
我尝试了这个方法，但有两个问题：1-boost:：dynamic\u pointer\u cast未成功（始终返回0）。2-将代码更改为：amop:：TMockObject*mock=new amop:：TMockObject；//获取模拟接口boost:：shared_ptr imock（（接口*）*mock）；几乎可以工作，但AMOP现在找不到方法，因此模拟不起作用。我很确定amop不能很好地处理共享指针（或者它们失去了引用之类的东西）