[mockitopp] r147 committed - mockitopp:...
4 views
Skip to first unread message
mock...@googlecode.com
Sep 29, 2012, 3:45:23 AM9/29/12
to mockit...@googlegroups.com
Revision: 147
Author: trevor.pounds
Date: Sat Sep 29 00:40:54 2012
Log: mockitopp:
* Compiler enforces thenReturn()/when() function ordering (Fixes issue 6)
* Fix matcher and global ==operator usage with namespaced classes (Fixes
issue 7)
* Prevent SIGSEGV when mocking class with virtual base (Fixes issue 8)
* Misc. cleanup
http://code.google.com/p/mockitopp/source/detail?r=147
Added:
/trunk/test/src/bugs
/trunk/test/src/bugs/issue_7.cpp
/trunk/test/src/bugs/issue_8.cpp
Modified:
/trunk/Build/BaseEnvironment.py
/trunk/SConstruct
/trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp
/trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp.m4
/trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp
/trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp.m4
/trunk/include/mockitopp/detail/util/pointers.hpp
/trunk/include/mockitopp/detail/util/tr1_tuple.hpp
/trunk/include/mockitopp/detail/util/tr1_tuple.hpp.m4
/trunk/include/mockitopp/exceptions.hpp
/trunk/include/mockitopp/mock_object.hpp
/trunk/test/SConscript
=======================================
--- /dev/null
+++ /trunk/test/src/bugs/issue_7.cpp Sat Sep 29 00:40:54 2012
@@ -0,0 +1,38 @@
+#include "tpunit++.hpp"
+#include <mockitopp/mockitopp.hpp>
+
+using namespace mockitopp;
+using namespace mockitopp::matcher;
+
+namespace issue_7_ns
+{
+ struct iface1 {};
+
+ struct iface2
+ {
+ virtual void func(iface1&) = 0;
+ };
+}
+
+bool operator==(issue_7_ns::iface1&, issue_7_ns::iface1&) { return true; }
+
+bool eq(issue_7_ns::iface1& lhs, issue_7_ns::iface1& rhs) { return lhs ==
rhs; }
+
+struct issue_7 : tpunit::TestFixture
+{
+ issue_7() : tpunit::TestFixture
+ (
+ TEST(issue_7::test_should_compile)
+ )
+ {}
+
+ void test_should_compile()
+ {
+ mock_object<issue_7_ns::iface2> mock;
+
mock(&issue_7_ns::iface2::func).when(any<issue_7_ns::iface1&>()).thenReturn();
+ issue_7_ns::iface2& obj = mock.getInstance();
+
+ issue_7_ns::iface1 arg;
+ ASSERT_NO_THROW(obj.func(arg));
+ }
+} issue_7__;
=======================================
--- /dev/null
+++ /trunk/test/src/bugs/issue_8.cpp Sat Sep 29 00:40:54 2012
@@ -0,0 +1,25 @@
+#include "tpunit++.hpp"
+#include <mockitopp/mockitopp.hpp>
+
+struct issue_8 : tpunit::TestFixture
+{
+ issue_8() : tpunit::TestFixture
+ (
+ TEST(issue_8::test_no_crash)
+ )
+ {}
+
+ struct vbase
+ {
+ virtual void func() = 0;
+ };
+
+ struct vderived : virtual vbase { };
+
+ void test_no_crash()
+ {
+ mockitopp::mock_object<vderived> mock;
+ mock(&vderived::func).when().thenReturn();
+ ASSERT_NO_THROW(mock.getInstance().func());
+ }
+} issue_8__;
=======================================
--- /trunk/Build/BaseEnvironment.py Mon Apr 20 19:59:25 2009
+++ /trunk/Build/BaseEnvironment.py Sat Sep 29 00:40:54 2012
@@ -24,6 +24,7 @@
apply(SConsEnvironment.__init__, (self,), kw)
self['CXX'] = os.getenv('CXX', self['CXX'])
self['CXXFLAGS'] = os.getenv('CXXFLAGS', self['CXXFLAGS'])
+ self['LINKFLAGS'] = os.getenv('LDFLAGS', self['LINKFLAGS'])
self['BUILDERS']['Test'] = self.Builder(action = self.Action(Test,
TestString),
suffix = '.dummy',
src_suffix =
self['PROGSUFFIX'])
=======================================
--- /trunk/SConstruct Fri Oct 7 23:33:10 2011
+++ /trunk/SConstruct Sat Sep 29 00:40:54 2012
@@ -3,7 +3,7 @@
env = Build.Environment()
Export('env')
-if 'm4-generate' in COMMAND_LINE_TARGETS:
+if 'm4' in COMMAND_LINE_TARGETS:
env.AppendUnique(M4FLAGS = [
'-I' + os.path.abspath(sys.path[0]) + '/include',
# maximum supported virtual functions, increase for classes with
large vtables
@@ -11,7 +11,7 @@
# maximum supported arity, increase for function signatures with
more arguments
'-DMOCKITOPP_MAX_VIRTUAL_FUNCTION_ARITY=10',
])
- Alias('m4-generate', [
+ Alias('m4', [
env.M4('include/mockitopp/detail/stubbing/dynamic_object.hpp.m4'),
env.M4('include/mockitopp/detail/stubbing/dynamic_vfunction.hpp.m4'),
env.M4('include/mockitopp/detail/stubbing/proxy_vfunction.hpp.m4'),
=======================================
--- /trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp Tue Nov 3
12:58:16 2009
+++ /trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp Sat Sep 29
00:40:54 2012
@@ -81,29 +81,40 @@
*/
struct dynamic_object
{
- struct vtable { void* __vtable[50]; };
+ struct vtable {
+ void* vbase_offset;
+ void* vcall_offset;
+ void* offset_to_top;
+ void* type_info;
+ void* functions[50];
+ };
- vtable* __vptr;
- void* __spys[50];
+ vtable* vtable_ptr;
+ void* vtable_mocks[50];
dynamic_object()
- : __vptr(new vtable)
+ : vtable_ptr(new vtable)
{
+ vtable_ptr->vbase_offset = 0;
+ vtable_ptr->vcall_offset = 0;
+ vtable_ptr->offset_to_top = 0;
+ vtable_ptr->type_info = 0;
for(int i = 0; i < 50; i++)
{
- __vptr->__vtable[i] =
horrible_cast<void*>(&dynamic_object::missing_vfunction);
- __spys[i] = 0;
+ vtable_ptr->functions[i] =
horrible_cast<void*>(&dynamic_object::missing_vfunction);
+ vtable_mocks[i] = 0;
}
}
~dynamic_object()
{
- // delete __vptr->__vtable[i] not necessary, entries point to
statically defined functions
- delete __vptr;
+ // delete vtable_ptr->functions[i] not necessary, entries
point to statically defined functions
+ vtable_ptr = (vtable*) (((char*) vtable_ptr) - sizeof(void*) *
4);
+ delete vtable_ptr;
for(int i = 0; i < 50; i++)
{
- if(__spys[i] != 0)
- { delete
reinterpret_cast<dynamic_vfunction_base*>(__spys[i]); }
+ if(vtable_mocks[i] != 0)
+ { delete
reinterpret_cast<dynamic_vfunction_base*>(vtable_mocks[i]); }
}
}
@@ -111,12 +122,12 @@
dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>& define_function(M ptr2member)
{
int offset = vtable_offset_helper::get(ptr2member);
- if(__spys[offset] == 0)
+ if(vtable_mocks[offset] == 0)
{
- __vptr->__vtable[offset] =
proxy_vfunction_factory<M>::get(ptr2member);
- __spys[offset] = new dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>();
+ vtable_ptr->functions[offset] =
proxy_vfunction_factory<M>::get(ptr2member);
+ vtable_mocks[offset] = new dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>();
}
- return *reinterpret_cast<dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>*>(__spys[offset]);
+ return *reinterpret_cast<dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>*>(vtable_mocks[offset]);
}
void missing_vfunction()
=======================================
--- /trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp.m4 Tue Nov
3 12:58:16 2009
+++ /trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp.m4 Sat Sep
29 00:40:54 2012
@@ -35,29 +35,40 @@
*/
struct dynamic_object
{
- struct vtable { void* __vtable[MOCKITOPP_MAX_VIRTUAL_FUNCTIONS];
};
+ struct vtable {
+ void* vbase_offset;
+ void* vcall_offset;
+ void* offset_to_top;
+ void* type_info;
+ void* functions[MOCKITOPP_MAX_VIRTUAL_FUNCTIONS];
+ };
- vtable* __vptr;
- void* __spys[MOCKITOPP_MAX_VIRTUAL_FUNCTIONS];
+ vtable* vtable_ptr;
+ void* vtable_mocks[MOCKITOPP_MAX_VIRTUAL_FUNCTIONS];
dynamic_object()
- : __vptr(new vtable)
+ : vtable_ptr(new vtable)
{
+ vtable_ptr->vbase_offset = 0;
+ vtable_ptr->vcall_offset = 0;
+ vtable_ptr->offset_to_top = 0;
+ vtable_ptr->type_info = 0;
for(int i = 0; i < MOCKITOPP_MAX_VIRTUAL_FUNCTIONS; i++)
{
- __vptr->__vtable[i] =
horrible_cast<void*>(&dynamic_object::missing_vfunction);
- __spys[i] = 0;
+ vtable_ptr->functions[i] =
horrible_cast<void*>(&dynamic_object::missing_vfunction);
+ vtable_mocks[i] = 0;
}
}
~dynamic_object()
{
- // delete __vptr->__vtable[i] not necessary, entries point to
statically defined functions
- delete __vptr;
+ // delete vtable_ptr->functions[i] not necessary, entries
point to statically defined functions
+ vtable_ptr = (vtable*) (((char*) vtable_ptr) - sizeof(void*) *
4);
+ delete vtable_ptr;
for(int i = 0; i < MOCKITOPP_MAX_VIRTUAL_FUNCTIONS; i++)
{
- if(__spys[i] != 0)
- { delete
reinterpret_cast<dynamic_vfunction_base*>(__spys[i]); }
+ if(vtable_mocks[i] != 0)
+ { delete
reinterpret_cast<dynamic_vfunction_base*>(vtable_mocks[i]); }
}
}
@@ -65,12 +76,12 @@
dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>& define_function(M ptr2member)
{
int offset = vtable_offset_helper::get(ptr2member);
- if(__spys[offset] == 0)
+ if(vtable_mocks[offset] == 0)
{
- __vptr->__vtable[offset] =
proxy_vfunction_factory<M>::get(ptr2member);
- __spys[offset] = new dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>();
+ vtable_ptr->functions[offset] =
proxy_vfunction_factory<M>::get(ptr2member);
+ vtable_mocks[offset] = new dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>();
}
- return *reinterpret_cast<dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>*>(__spys[offset]);
+ return *reinterpret_cast<dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>*>(vtable_mocks[offset]);
}
void missing_vfunction()
=======================================
--- /trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp Sat Oct
15 01:17:47 2011
+++ /trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp Sat Sep
29 00:40:54 2012
@@ -46,7 +46,7 @@
* @param times minimum number of times method should be called
*/
bool atLeast(int times) const
- { return between(times, 0x7FFF); }
+ { return calls >= times; }
/**
* verify method is called at most (n) times
@@ -54,7 +54,7 @@
* @param times maximum number of times method should be called
*/
bool atMost(int times) const
- { return between(0, times); }
+ { return calls <= times; }
/**
* verify method is called exactly (n) times
@@ -62,17 +62,17 @@
* @param times exact number of times method should be called
*/
bool exactly(int times) const
- { return between(times, times); }
+ { return calls == times; }
/**
* verify method is never called
*/
bool never() const
- { return between(0, 0); }
+ { return calls == 0; }
};
template <typename R>
- struct dynamic_vfunction_action : dynamic_vfunction_base
+ struct dynamic_vfunction_action
{
typedef shared_ptr<action<R> > action_type;
typedef std::list<action_type> action_queue_type;
@@ -94,7 +94,7 @@
};
template <>
- struct dynamic_vfunction_action<void> : dynamic_vfunction_base
+ struct dynamic_vfunction_action<void>
{
typedef shared_ptr<action<void> > action_type;
typedef std::list<action_type> action_queue_type;
@@ -159,11 +159,13 @@
// TODO: clean up impl
// TODO: add sequence matcher
- //TODO: clean up typedef nomenclature
+ // TODO: clean up typedef nomenclature
// 0 arity template
template <typename R, typename C>
- struct dynamic_vfunction<R (C::*)()> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)()>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<> raw_tuple_type;
typedef tr1::tuple< > matcher_tuple_type;
@@ -176,13 +178,14 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when()
+ dynamic_vfunction_action<R>& when()
{
raw_tuple_type args = raw_tuple_type();
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -222,7 +225,9 @@
// 1 arity template
template <typename R, typename C, typename A0>
- struct dynamic_vfunction<R (C::*)(A0)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 > > matcher_tuple_type;
@@ -235,11 +240,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >& a0)
{
matcher_tuple_type args = matcher_tuple_type(a0);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -253,7 +259,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0)
+ dynamic_vfunction_action<R>& when(A0 a0)
{
raw_tuple_type args = raw_tuple_type(a0);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -293,7 +299,9 @@
// 2 arity template
template <typename R, typename C, typename A0, typename A1>
- struct dynamic_vfunction<R (C::*)(A0, A1)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 > >
matcher_tuple_type;
@@ -306,11 +314,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -324,7 +333,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1)
{
raw_tuple_type args = raw_tuple_type(a0, a1);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -364,7 +373,9 @@
// 3 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 > > matcher_tuple_type;
@@ -377,11 +388,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -395,7 +407,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -435,7 +447,9 @@
// 4 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 > > matcher_tuple_type;
@@ -448,11 +462,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -466,7 +481,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -506,7 +521,9 @@
// 5 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 > >
matcher_tuple_type;
@@ -519,11 +536,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -537,7 +555,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -577,7 +595,9 @@
// 6 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4, typename A5>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4, A5> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 >,
matcher_element<A5 > > matcher_tuple_type;
@@ -590,11 +610,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4, a5);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -608,7 +629,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4, A5 a5)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4, a5);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -648,7 +669,9 @@
// 7 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4, typename A5, typename A6>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6)> :
public dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4, A5, A6> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 >,
matcher_element<A5 >, matcher_element<A6 > > matcher_tuple_type;
@@ -661,11 +684,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4, a5, a6);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -679,7 +703,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
A6 a6)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4, A5 a5, A6 a6)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4, a5,
a6);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -719,7 +743,9 @@
// 8 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4, typename A5, typename A6, typename A7>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7)> :
public dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4, A5, A6, A7> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 >,
matcher_element<A5 >, matcher_element<A6 >, matcher_element<A7 > >
matcher_tuple_type;
@@ -732,11 +758,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4, a5, a6, a7);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -750,7 +777,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
A6 a6, A7 a7)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4, A5 a5, A6 a6, A7 a7)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4, a5,
a6, a7);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -790,7 +817,9 @@
// 9 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4, typename A5, typename A6, typename A7,
typename A8>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7,
A8)> : public dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7,
A8)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>
raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 >,
matcher_element<A5 >, matcher_element<A6 >, matcher_element<A7 >,
matcher_element<A8 > > matcher_tuple_type;
@@ -803,11 +832,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7, const matcher::Matcher<A8 >& a8)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7, const matcher::Matcher<A8 >& a8)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4, a5, a6, a7, a8);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -821,7 +851,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
A6 a6, A7 a7, A8 a8)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4, a5,
a6, a7, a8);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -861,7 +891,9 @@
// 10 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4, typename A5, typename A6, typename A7,
typename A8, typename A9>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7,
A8, A9)> : public dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7,
A8, A9)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>
raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 >,
matcher_element<A5 >, matcher_element<A6 >, matcher_element<A7 >,
matcher_element<A8 >, matcher_element<A9 > > matcher_tuple_type;
@@ -874,11 +906,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7, const matcher::Matcher<A8 >& a8, const
matcher::Matcher<A9 >& a9)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7, const matcher::Matcher<A8 >& a8, const
matcher::Matcher<A9 >& a9)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4, a5, a6, a7, a8, a9);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -892,7 +925,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
A6 a6, A7 a7, A8 a8, A9 a9)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4, a5,
a6, a7, a8, a9);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
=======================================
--- /trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp.m4 Sat
Oct 15 01:17:47 2011
+++ /trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp.m4 Sat
Sep 29 00:40:54 2012
@@ -51,7 +51,7 @@
* @param times minimum number of times method should be called
*/
bool atLeast(int times) const
- { return between(times, 0x7FFF); }
+ { return calls >= times; }
/**
* verify method is called at most (n) times
@@ -59,7 +59,7 @@
* @param times maximum number of times method should be called
*/
bool atMost(int times) const
- { return between(0, times); }
+ { return calls <= times; }
/**
* verify method is called exactly (n) times
@@ -67,17 +67,17 @@
* @param times exact number of times method should be called
*/
bool exactly(int times) const
- { return between(times, times); }
+ { return calls == times; }
/**
* verify method is never called
*/
bool never() const
- { return between(0, 0); }
+ { return calls == 0; }
};
template <typename R>
- struct dynamic_vfunction_action : dynamic_vfunction_base
+ struct dynamic_vfunction_action
{
typedef shared_ptr<action<R> > action_type;
typedef std::list<action_type> action_queue_type;
@@ -99,7 +99,7 @@
};
template <>
- struct dynamic_vfunction_action<void> : dynamic_vfunction_base
+ struct dynamic_vfunction_action<void>
{
typedef shared_ptr<action<void> > action_type;
typedef std::list<action_type> action_queue_type;
@@ -164,11 +164,13 @@
// TODO: clean up impl
// TODO: add sequence matcher
- //TODO: clean up typedef nomenclature
+ // TODO: clean up typedef nomenclature
define(`DEFINE_DYNAMIC_VFUNCTION', `
// $1 arity template
template <typename R, typename C`'M4_ENUM_TRAILING_PARAMS($1,
typename A)>
- struct dynamic_vfunction<R (C::*)(M4_ENUM_PARAMS($1, A))> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(M4_ENUM_PARAMS($1, A))>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<M4_ENUM_PARAMS($1, A)> raw_tuple_type;
typedef tr1::tuple<M4_ENUM_BINARY_PARAMS($1, matcher_element<A,
>, M4_INTERCEPT) > matcher_tuple_type;
@@ -181,11 +183,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- M4_IF($1, `dynamic_vfunction& when(M4_ENUM_BINARY_PARAMS($1,
const matcher::Matcher<A, >& a))
+ M4_IF($1, `dynamic_vfunction_action<R>&
when(M4_ENUM_BINARY_PARAMS($1, const matcher::Matcher<A, >& a))
{
matcher_tuple_type args =
matcher_tuple_type(M4_ENUM_PARAMS($1, a));
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -199,7 +202,7 @@
return *this;
}',)
- dynamic_vfunction& when(M4_ENUM_BINARY_PARAMS($1, A, a))
+ dynamic_vfunction_action<R>& when(M4_ENUM_BINARY_PARAMS($1, A, a))
{
raw_tuple_type args = raw_tuple_type(M4_ENUM_PARAMS($1, a));
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
=======================================
--- /trunk/include/mockitopp/detail/util/pointers.hpp Mon Oct 10 21:29:27
2011
+++ /trunk/include/mockitopp/detail/util/pointers.hpp Sat Sep 29 00:40:54
2012
@@ -83,10 +83,7 @@
{}
~shared_ptr_impl()
- {
- static D DELETER;
- DELETER(_raw_ptr);
- }
+ { D()(_raw_ptr); }
}* _ptr_impl;
void __decrement()
@@ -196,8 +193,7 @@
{
if(is_owner())
{
- static D DELETER = D();
- DELETER(get());
+ D()(get());
_ptr = 0;
}
}
=======================================
--- /trunk/include/mockitopp/detail/util/tr1_tuple.hpp Mon Sep 19 17:11:06
2011
+++ /trunk/include/mockitopp/detail/util/tr1_tuple.hpp Sat Sep 29 00:40:54
2012
@@ -21,15 +21,7 @@
{
namespace tr1
{
- struct tuple_null_type
- {
- bool operator== (const tuple_null_type&) const { return true; }
- bool operator!= (const tuple_null_type&) const { return false;
}
- bool operator< (const tuple_null_type&) const { return false;
}
- bool operator<= (const tuple_null_type&) const { return true; }
- bool operator> (const tuple_null_type&) const { return false;
}
- bool operator>= (const tuple_null_type&) const { return true; }
- };
+ struct tuple_null_type {};
template <typename H, typename T>
struct tuple_cons
@@ -43,32 +35,6 @@
, tail_(tail)
{}
};
-
- // TODO: fix comparison ops?
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator== (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ == rhs.head_) && (lhs.tail_ == rhs.tail_);
}
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator!= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return !(lhs == rhs); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator< (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ < rhs.head_) || (lhs.tail_ < rhs.tail_); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator<= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs == rhs) || (lhs < rhs); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator> (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ > rhs.head_) && (lhs.tail_ > rhs.tail_); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator>= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs == rhs) || (lhs > rhs); }
// 10 element template
template <typename T0 = tuple_null_type, typename T1 =
tuple_null_type, typename T2 = tuple_null_type, typename T3 =
tuple_null_type, typename T4 = tuple_null_type, typename T5 =
tuple_null_type, typename T6 = tuple_null_type, typename T7 =
tuple_null_type, typename T8 = tuple_null_type, typename T9 =
tuple_null_type>
@@ -204,5 +170,36 @@
} // namespace tr1
} // namespace detail
} // namespace mockitopp
+
+inline bool operator== (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+inline bool operator!= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator< (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator<= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+inline bool operator> (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator>= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator== (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ == rhs.head_) && (lhs.tail_ == rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator!= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return !(lhs == rhs); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator< (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ < rhs.head_) || (lhs.tail_ < rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator<= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs == rhs) || (lhs < rhs); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator> (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ > rhs.head_) && (lhs.tail_ > rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator>= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs == rhs) || (lhs > rhs); }
#endif //__MOCKITOPP_TR1_TUPLE_HPP__
=======================================
--- /trunk/include/mockitopp/detail/util/tr1_tuple.hpp.m4 Mon Sep 19
17:11:06 2011
+++ /trunk/include/mockitopp/detail/util/tr1_tuple.hpp.m4 Sat Sep 29
00:40:54 2012
@@ -26,15 +26,7 @@
{
namespace tr1
{
- struct tuple_null_type
- {
- bool operator== (const tuple_null_type&) const { return true; }
- bool operator!= (const tuple_null_type&) const { return false;
}
- bool operator< (const tuple_null_type&) const { return false;
}
- bool operator<= (const tuple_null_type&) const { return true; }
- bool operator> (const tuple_null_type&) const { return false;
}
- bool operator>= (const tuple_null_type&) const { return true; }
- };
+ struct tuple_null_type {};
template <typename H, typename T>
struct tuple_cons
@@ -48,32 +40,6 @@
, tail_(tail)
{}
};
-
- // TODO: fix comparison ops?
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator== (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ == rhs.head_) && (lhs.tail_ == rhs.tail_);
}
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator!= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return !(lhs == rhs); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator< (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ < rhs.head_) || (lhs.tail_ < rhs.tail_); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator<= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs == rhs) || (lhs < rhs); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator> (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ > rhs.head_) && (lhs.tail_ > rhs.tail_); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator>= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs == rhs) || (lhs > rhs); }
// MOCKITOPP_MAX_VIRTUAL_FUNCTION_ARITY element template
template
<M4_ENUM_BINARY_PARAMS(MOCKITOPP_MAX_VIRTUAL_FUNCTION_ARITY, typename T, =
tuple_null_type, M4_INTERCEPT)>
@@ -117,5 +83,36 @@
} // namespace tr1
} // namespace detail
} // namespace mockitopp
+
+inline bool operator== (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+inline bool operator!= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator< (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator<= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+inline bool operator> (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator>= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator== (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ == rhs.head_) && (lhs.tail_ == rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator!= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return !(lhs == rhs); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator< (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ < rhs.head_) || (lhs.tail_ < rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator<= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs == rhs) || (lhs < rhs); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator> (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ > rhs.head_) && (lhs.tail_ > rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator>= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs == rhs) || (lhs > rhs); }
#endif //__MOCKITOPP_TR1_TUPLE_HPP__
=======================================
--- /trunk/include/mockitopp/exceptions.hpp Sat Aug 15 15:20:09 2009
+++ /trunk/include/mockitopp/exceptions.hpp Sat Sep 29 00:40:54 2012
@@ -5,17 +5,16 @@
namespace mockitopp
{
- struct partial_implementation_exception : public ::std::exception
- {
- const char *what() const throw()
- { return "function has partial implementation!"; }
- };
+ #define MOCKITO_EXCEPTION(EEE) struct EEE : public ::std::exception {};
- struct missing_implementation_exception : public ::std::exception
- {
- const char *what() const throw()
- { return "function has no implementation!"; }
- };
+ MOCKITO_EXCEPTION(partial_implementation_exception)
+ MOCKITO_EXCEPTION(missing_implementation_exception)
+
+ MOCKITO_EXCEPTION(less_invocations_expected);
+ MOCKITO_EXCEPTION(more_invocations_expected);
+ MOCKITO_EXCEPTION(zero_invocations_expected);
+
+ #undef MOCKITO_EXCEPTION
} // namespace mockitopp
#endif //__MOCKITOPP_EXCEPTIONS_HPP__
=======================================
--- /trunk/include/mockitopp/mock_object.hpp Fri Dec 10 16:59:15 2010
+++ /trunk/include/mockitopp/mock_object.hpp Sat Sep 29 00:40:54 2012
@@ -25,7 +25,10 @@
* @return mock object
*/
T& getInstance()
- { return reinterpret_cast<T&>(*this); }
+ {
+ vtable_ptr = (vtable*) (((char*) vtable_ptr) + sizeof(void*) * 4);
+ return reinterpret_cast<T&>(*this);
+ }
/**
* stub functionality for a given method
=======================================
--- /trunk/test/SConscript Fri Oct 7 23:33:10 2011
+++ /trunk/test/SConscript Sat Sep 29 00:40:54 2012
@@ -41,6 +41,8 @@
'src/test_multiple_inheritance.cpp',
'src/test_overloaded_functions.cpp',
'src/test_verify.cpp',
+ 'src/bugs/issue_7.cpp',
+ 'src/bugs/issue_8.cpp',
'src/compiler/alignment.cpp',
'src/compiler/pointer_size.cpp',
'src/matchers/test_any.cpp',
Author: trevor.pounds
Date: Sat Sep 29 00:40:54 2012
Log: mockitopp:
* Compiler enforces thenReturn()/when() function ordering (Fixes issue 6)
* Fix matcher and global ==operator usage with namespaced classes (Fixes
issue 7)
* Prevent SIGSEGV when mocking class with virtual base (Fixes issue 8)
* Misc. cleanup
http://code.google.com/p/mockitopp/source/detail?r=147
Added:
/trunk/test/src/bugs
/trunk/test/src/bugs/issue_7.cpp
/trunk/test/src/bugs/issue_8.cpp
Modified:
/trunk/Build/BaseEnvironment.py
/trunk/SConstruct
/trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp
/trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp.m4
/trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp
/trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp.m4
/trunk/include/mockitopp/detail/util/pointers.hpp
/trunk/include/mockitopp/detail/util/tr1_tuple.hpp
/trunk/include/mockitopp/detail/util/tr1_tuple.hpp.m4
/trunk/include/mockitopp/exceptions.hpp
/trunk/include/mockitopp/mock_object.hpp
/trunk/test/SConscript
=======================================
--- /dev/null
+++ /trunk/test/src/bugs/issue_7.cpp Sat Sep 29 00:40:54 2012
@@ -0,0 +1,38 @@
+#include "tpunit++.hpp"
+#include <mockitopp/mockitopp.hpp>
+
+using namespace mockitopp;
+using namespace mockitopp::matcher;
+
+namespace issue_7_ns
+{
+ struct iface1 {};
+
+ struct iface2
+ {
+ virtual void func(iface1&) = 0;
+ };
+}
+
+bool operator==(issue_7_ns::iface1&, issue_7_ns::iface1&) { return true; }
+
+bool eq(issue_7_ns::iface1& lhs, issue_7_ns::iface1& rhs) { return lhs ==
rhs; }
+
+struct issue_7 : tpunit::TestFixture
+{
+ issue_7() : tpunit::TestFixture
+ (
+ TEST(issue_7::test_should_compile)
+ )
+ {}
+
+ void test_should_compile()
+ {
+ mock_object<issue_7_ns::iface2> mock;
+
mock(&issue_7_ns::iface2::func).when(any<issue_7_ns::iface1&>()).thenReturn();
+ issue_7_ns::iface2& obj = mock.getInstance();
+
+ issue_7_ns::iface1 arg;
+ ASSERT_NO_THROW(obj.func(arg));
+ }
+} issue_7__;
=======================================
--- /dev/null
+++ /trunk/test/src/bugs/issue_8.cpp Sat Sep 29 00:40:54 2012
@@ -0,0 +1,25 @@
+#include "tpunit++.hpp"
+#include <mockitopp/mockitopp.hpp>
+
+struct issue_8 : tpunit::TestFixture
+{
+ issue_8() : tpunit::TestFixture
+ (
+ TEST(issue_8::test_no_crash)
+ )
+ {}
+
+ struct vbase
+ {
+ virtual void func() = 0;
+ };
+
+ struct vderived : virtual vbase { };
+
+ void test_no_crash()
+ {
+ mockitopp::mock_object<vderived> mock;
+ mock(&vderived::func).when().thenReturn();
+ ASSERT_NO_THROW(mock.getInstance().func());
+ }
+} issue_8__;
=======================================
--- /trunk/Build/BaseEnvironment.py Mon Apr 20 19:59:25 2009
+++ /trunk/Build/BaseEnvironment.py Sat Sep 29 00:40:54 2012
@@ -24,6 +24,7 @@
apply(SConsEnvironment.__init__, (self,), kw)
self['CXX'] = os.getenv('CXX', self['CXX'])
self['CXXFLAGS'] = os.getenv('CXXFLAGS', self['CXXFLAGS'])
+ self['LINKFLAGS'] = os.getenv('LDFLAGS', self['LINKFLAGS'])
self['BUILDERS']['Test'] = self.Builder(action = self.Action(Test,
TestString),
suffix = '.dummy',
src_suffix =
self['PROGSUFFIX'])
=======================================
--- /trunk/SConstruct Fri Oct 7 23:33:10 2011
+++ /trunk/SConstruct Sat Sep 29 00:40:54 2012
@@ -3,7 +3,7 @@
env = Build.Environment()
Export('env')
-if 'm4-generate' in COMMAND_LINE_TARGETS:
+if 'm4' in COMMAND_LINE_TARGETS:
env.AppendUnique(M4FLAGS = [
'-I' + os.path.abspath(sys.path[0]) + '/include',
# maximum supported virtual functions, increase for classes with
large vtables
@@ -11,7 +11,7 @@
# maximum supported arity, increase for function signatures with
more arguments
'-DMOCKITOPP_MAX_VIRTUAL_FUNCTION_ARITY=10',
])
- Alias('m4-generate', [
+ Alias('m4', [
env.M4('include/mockitopp/detail/stubbing/dynamic_object.hpp.m4'),
env.M4('include/mockitopp/detail/stubbing/dynamic_vfunction.hpp.m4'),
env.M4('include/mockitopp/detail/stubbing/proxy_vfunction.hpp.m4'),
=======================================
--- /trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp Tue Nov 3
12:58:16 2009
+++ /trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp Sat Sep 29
00:40:54 2012
@@ -81,29 +81,40 @@
*/
struct dynamic_object
{
- struct vtable { void* __vtable[50]; };
+ struct vtable {
+ void* vbase_offset;
+ void* vcall_offset;
+ void* offset_to_top;
+ void* type_info;
+ void* functions[50];
+ };
- vtable* __vptr;
- void* __spys[50];
+ vtable* vtable_ptr;
+ void* vtable_mocks[50];
dynamic_object()
- : __vptr(new vtable)
+ : vtable_ptr(new vtable)
{
+ vtable_ptr->vbase_offset = 0;
+ vtable_ptr->vcall_offset = 0;
+ vtable_ptr->offset_to_top = 0;
+ vtable_ptr->type_info = 0;
for(int i = 0; i < 50; i++)
{
- __vptr->__vtable[i] =
horrible_cast<void*>(&dynamic_object::missing_vfunction);
- __spys[i] = 0;
+ vtable_ptr->functions[i] =
horrible_cast<void*>(&dynamic_object::missing_vfunction);
+ vtable_mocks[i] = 0;
}
}
~dynamic_object()
{
- // delete __vptr->__vtable[i] not necessary, entries point to
statically defined functions
- delete __vptr;
+ // delete vtable_ptr->functions[i] not necessary, entries
point to statically defined functions
+ vtable_ptr = (vtable*) (((char*) vtable_ptr) - sizeof(void*) *
4);
+ delete vtable_ptr;
for(int i = 0; i < 50; i++)
{
- if(__spys[i] != 0)
- { delete
reinterpret_cast<dynamic_vfunction_base*>(__spys[i]); }
+ if(vtable_mocks[i] != 0)
+ { delete
reinterpret_cast<dynamic_vfunction_base*>(vtable_mocks[i]); }
}
}
@@ -111,12 +122,12 @@
dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>& define_function(M ptr2member)
{
int offset = vtable_offset_helper::get(ptr2member);
- if(__spys[offset] == 0)
+ if(vtable_mocks[offset] == 0)
{
- __vptr->__vtable[offset] =
proxy_vfunction_factory<M>::get(ptr2member);
- __spys[offset] = new dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>();
+ vtable_ptr->functions[offset] =
proxy_vfunction_factory<M>::get(ptr2member);
+ vtable_mocks[offset] = new dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>();
}
- return *reinterpret_cast<dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>*>(__spys[offset]);
+ return *reinterpret_cast<dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>*>(vtable_mocks[offset]);
}
void missing_vfunction()
=======================================
--- /trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp.m4 Tue Nov
3 12:58:16 2009
+++ /trunk/include/mockitopp/detail/stubbing/dynamic_object.hpp.m4 Sat Sep
29 00:40:54 2012
@@ -35,29 +35,40 @@
*/
struct dynamic_object
{
- struct vtable { void* __vtable[MOCKITOPP_MAX_VIRTUAL_FUNCTIONS];
};
+ struct vtable {
+ void* vbase_offset;
+ void* vcall_offset;
+ void* offset_to_top;
+ void* type_info;
+ void* functions[MOCKITOPP_MAX_VIRTUAL_FUNCTIONS];
+ };
- vtable* __vptr;
- void* __spys[MOCKITOPP_MAX_VIRTUAL_FUNCTIONS];
+ vtable* vtable_ptr;
+ void* vtable_mocks[MOCKITOPP_MAX_VIRTUAL_FUNCTIONS];
dynamic_object()
- : __vptr(new vtable)
+ : vtable_ptr(new vtable)
{
+ vtable_ptr->vbase_offset = 0;
+ vtable_ptr->vcall_offset = 0;
+ vtable_ptr->offset_to_top = 0;
+ vtable_ptr->type_info = 0;
for(int i = 0; i < MOCKITOPP_MAX_VIRTUAL_FUNCTIONS; i++)
{
- __vptr->__vtable[i] =
horrible_cast<void*>(&dynamic_object::missing_vfunction);
- __spys[i] = 0;
+ vtable_ptr->functions[i] =
horrible_cast<void*>(&dynamic_object::missing_vfunction);
+ vtable_mocks[i] = 0;
}
}
~dynamic_object()
{
- // delete __vptr->__vtable[i] not necessary, entries point to
statically defined functions
- delete __vptr;
+ // delete vtable_ptr->functions[i] not necessary, entries
point to statically defined functions
+ vtable_ptr = (vtable*) (((char*) vtable_ptr) - sizeof(void*) *
4);
+ delete vtable_ptr;
for(int i = 0; i < MOCKITOPP_MAX_VIRTUAL_FUNCTIONS; i++)
{
- if(__spys[i] != 0)
- { delete
reinterpret_cast<dynamic_vfunction_base*>(__spys[i]); }
+ if(vtable_mocks[i] != 0)
+ { delete
reinterpret_cast<dynamic_vfunction_base*>(vtable_mocks[i]); }
}
}
@@ -65,12 +76,12 @@
dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>& define_function(M ptr2member)
{
int offset = vtable_offset_helper::get(ptr2member);
- if(__spys[offset] == 0)
+ if(vtable_mocks[offset] == 0)
{
- __vptr->__vtable[offset] =
proxy_vfunction_factory<M>::get(ptr2member);
- __spys[offset] = new dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>();
+ vtable_ptr->functions[offset] =
proxy_vfunction_factory<M>::get(ptr2member);
+ vtable_mocks[offset] = new dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>();
}
- return *reinterpret_cast<dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>*>(__spys[offset]);
+ return *reinterpret_cast<dynamic_vfunction<typename
remove_member_function_pointer_cv<M>::type>*>(vtable_mocks[offset]);
}
void missing_vfunction()
=======================================
--- /trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp Sat Oct
15 01:17:47 2011
+++ /trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp Sat Sep
29 00:40:54 2012
@@ -46,7 +46,7 @@
* @param times minimum number of times method should be called
*/
bool atLeast(int times) const
- { return between(times, 0x7FFF); }
+ { return calls >= times; }
/**
* verify method is called at most (n) times
@@ -54,7 +54,7 @@
* @param times maximum number of times method should be called
*/
bool atMost(int times) const
- { return between(0, times); }
+ { return calls <= times; }
/**
* verify method is called exactly (n) times
@@ -62,17 +62,17 @@
* @param times exact number of times method should be called
*/
bool exactly(int times) const
- { return between(times, times); }
+ { return calls == times; }
/**
* verify method is never called
*/
bool never() const
- { return between(0, 0); }
+ { return calls == 0; }
};
template <typename R>
- struct dynamic_vfunction_action : dynamic_vfunction_base
+ struct dynamic_vfunction_action
{
typedef shared_ptr<action<R> > action_type;
typedef std::list<action_type> action_queue_type;
@@ -94,7 +94,7 @@
};
template <>
- struct dynamic_vfunction_action<void> : dynamic_vfunction_base
+ struct dynamic_vfunction_action<void>
{
typedef shared_ptr<action<void> > action_type;
typedef std::list<action_type> action_queue_type;
@@ -159,11 +159,13 @@
// TODO: clean up impl
// TODO: add sequence matcher
- //TODO: clean up typedef nomenclature
+ // TODO: clean up typedef nomenclature
// 0 arity template
template <typename R, typename C>
- struct dynamic_vfunction<R (C::*)()> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)()>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<> raw_tuple_type;
typedef tr1::tuple< > matcher_tuple_type;
@@ -176,13 +178,14 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when()
+ dynamic_vfunction_action<R>& when()
{
raw_tuple_type args = raw_tuple_type();
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -222,7 +225,9 @@
// 1 arity template
template <typename R, typename C, typename A0>
- struct dynamic_vfunction<R (C::*)(A0)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 > > matcher_tuple_type;
@@ -235,11 +240,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >& a0)
{
matcher_tuple_type args = matcher_tuple_type(a0);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -253,7 +259,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0)
+ dynamic_vfunction_action<R>& when(A0 a0)
{
raw_tuple_type args = raw_tuple_type(a0);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -293,7 +299,9 @@
// 2 arity template
template <typename R, typename C, typename A0, typename A1>
- struct dynamic_vfunction<R (C::*)(A0, A1)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 > >
matcher_tuple_type;
@@ -306,11 +314,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -324,7 +333,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1)
{
raw_tuple_type args = raw_tuple_type(a0, a1);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -364,7 +373,9 @@
// 3 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 > > matcher_tuple_type;
@@ -377,11 +388,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -395,7 +407,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -435,7 +447,9 @@
// 4 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 > > matcher_tuple_type;
@@ -448,11 +462,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -466,7 +481,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -506,7 +521,9 @@
// 5 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 > >
matcher_tuple_type;
@@ -519,11 +536,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -537,7 +555,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -577,7 +595,9 @@
// 6 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4, typename A5>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5)> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4, A5> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 >,
matcher_element<A5 > > matcher_tuple_type;
@@ -590,11 +610,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4, a5);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -608,7 +629,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4, A5 a5)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4, a5);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -648,7 +669,9 @@
// 7 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4, typename A5, typename A6>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6)> :
public dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4, A5, A6> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 >,
matcher_element<A5 >, matcher_element<A6 > > matcher_tuple_type;
@@ -661,11 +684,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4, a5, a6);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -679,7 +703,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
A6 a6)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4, A5 a5, A6 a6)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4, a5,
a6);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -719,7 +743,9 @@
// 8 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4, typename A5, typename A6, typename A7>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7)> :
public dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4, A5, A6, A7> raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 >,
matcher_element<A5 >, matcher_element<A6 >, matcher_element<A7 > >
matcher_tuple_type;
@@ -732,11 +758,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4, a5, a6, a7);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -750,7 +777,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
A6 a6, A7 a7)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4, A5 a5, A6 a6, A7 a7)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4, a5,
a6, a7);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -790,7 +817,9 @@
// 9 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4, typename A5, typename A6, typename A7,
typename A8>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7,
A8)> : public dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7,
A8)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>
raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 >,
matcher_element<A5 >, matcher_element<A6 >, matcher_element<A7 >,
matcher_element<A8 > > matcher_tuple_type;
@@ -803,11 +832,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7, const matcher::Matcher<A8 >& a8)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7, const matcher::Matcher<A8 >& a8)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4, a5, a6, a7, a8);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -821,7 +851,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
A6 a6, A7 a7, A8 a8)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4, a5,
a6, a7, a8);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -861,7 +891,9 @@
// 10 arity template
template <typename R, typename C, typename A0, typename A1, typename
A2, typename A3, typename A4, typename A5, typename A6, typename A7,
typename A8, typename A9>
- struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7,
A8, A9)> : public dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(A0, A1, A2, A3, A4, A5, A6, A7,
A8, A9)>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>
raw_tuple_type;
typedef tr1::tuple<matcher_element<A0 >, matcher_element<A1 >,
matcher_element<A2 >, matcher_element<A3 >, matcher_element<A4 >,
matcher_element<A5 >, matcher_element<A6 >, matcher_element<A7 >,
matcher_element<A8 >, matcher_element<A9 > > matcher_tuple_type;
@@ -874,11 +906,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- dynamic_vfunction& when(const matcher::Matcher<A0 >& a0, const
matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7, const matcher::Matcher<A8 >& a8, const
matcher::Matcher<A9 >& a9)
+ dynamic_vfunction_action<R>& when(const matcher::Matcher<A0 >&
a0, const matcher::Matcher<A1 >& a1, const matcher::Matcher<A2 >& a2, const
matcher::Matcher<A3 >& a3, const matcher::Matcher<A4 >& a4, const
matcher::Matcher<A5 >& a5, const matcher::Matcher<A6 >& a6, const
matcher::Matcher<A7 >& a7, const matcher::Matcher<A8 >& a8, const
matcher::Matcher<A9 >& a9)
{
matcher_tuple_type args = matcher_tuple_type(a0, a1, a2, a3,
a4, a5, a6, a7, a8, a9);
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -892,7 +925,7 @@
return *this;
}
- dynamic_vfunction& when(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
A6 a6, A7 a7, A8 a8, A9 a9)
+ dynamic_vfunction_action<R>& when(A0 a0, A1 a1, A2 a2, A3 a3, A4
a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
raw_tuple_type args = raw_tuple_type(a0, a1, a2, a3, a4, a5,
a6, a7, a8, a9);
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
=======================================
--- /trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp.m4 Sat
Oct 15 01:17:47 2011
+++ /trunk/include/mockitopp/detail/stubbing/dynamic_vfunction.hpp.m4 Sat
Sep 29 00:40:54 2012
@@ -51,7 +51,7 @@
* @param times minimum number of times method should be called
*/
bool atLeast(int times) const
- { return between(times, 0x7FFF); }
+ { return calls >= times; }
/**
* verify method is called at most (n) times
@@ -59,7 +59,7 @@
* @param times maximum number of times method should be called
*/
bool atMost(int times) const
- { return between(0, times); }
+ { return calls <= times; }
/**
* verify method is called exactly (n) times
@@ -67,17 +67,17 @@
* @param times exact number of times method should be called
*/
bool exactly(int times) const
- { return between(times, times); }
+ { return calls == times; }
/**
* verify method is never called
*/
bool never() const
- { return between(0, 0); }
+ { return calls == 0; }
};
template <typename R>
- struct dynamic_vfunction_action : dynamic_vfunction_base
+ struct dynamic_vfunction_action
{
typedef shared_ptr<action<R> > action_type;
typedef std::list<action_type> action_queue_type;
@@ -99,7 +99,7 @@
};
template <>
- struct dynamic_vfunction_action<void> : dynamic_vfunction_base
+ struct dynamic_vfunction_action<void>
{
typedef shared_ptr<action<void> > action_type;
typedef std::list<action_type> action_queue_type;
@@ -164,11 +164,13 @@
// TODO: clean up impl
// TODO: add sequence matcher
- //TODO: clean up typedef nomenclature
+ // TODO: clean up typedef nomenclature
define(`DEFINE_DYNAMIC_VFUNCTION', `
// $1 arity template
template <typename R, typename C`'M4_ENUM_TRAILING_PARAMS($1,
typename A)>
- struct dynamic_vfunction<R (C::*)(M4_ENUM_PARAMS($1, A))> : public
dynamic_vfunction_action<R>
+ struct dynamic_vfunction<R (C::*)(M4_ENUM_PARAMS($1, A))>
+ : private dynamic_vfunction_action<R>
+ , public dynamic_vfunction_base
{
typedef tr1::tuple<M4_ENUM_PARAMS($1, A)> raw_tuple_type;
typedef tr1::tuple<M4_ENUM_BINARY_PARAMS($1, matcher_element<A,
>, M4_INTERCEPT) > matcher_tuple_type;
@@ -181,11 +183,12 @@
dynamic_vfunction()
: dynamic_vfunction_action<R>()
+ , dynamic_vfunction_base()
, raw_actions_map()
, matcher_actions_map()
{}
- M4_IF($1, `dynamic_vfunction& when(M4_ENUM_BINARY_PARAMS($1,
const matcher::Matcher<A, >& a))
+ M4_IF($1, `dynamic_vfunction_action<R>&
when(M4_ENUM_BINARY_PARAMS($1, const matcher::Matcher<A, >& a))
{
matcher_tuple_type args =
matcher_tuple_type(M4_ENUM_PARAMS($1, a));
typename std::list<key_comparable_pair<matcher_tuple_type,
action_queue_type> >::iterator pair_it;
@@ -199,7 +202,7 @@
return *this;
}',)
- dynamic_vfunction& when(M4_ENUM_BINARY_PARAMS($1, A, a))
+ dynamic_vfunction_action<R>& when(M4_ENUM_BINARY_PARAMS($1, A, a))
{
raw_tuple_type args = raw_tuple_type(M4_ENUM_PARAMS($1, a));
typename std::list<key_comparable_pair<raw_tuple_type,
action_queue_type> >::iterator pair_it;
=======================================
--- /trunk/include/mockitopp/detail/util/pointers.hpp Mon Oct 10 21:29:27
2011
+++ /trunk/include/mockitopp/detail/util/pointers.hpp Sat Sep 29 00:40:54
2012
@@ -83,10 +83,7 @@
{}
~shared_ptr_impl()
- {
- static D DELETER;
- DELETER(_raw_ptr);
- }
+ { D()(_raw_ptr); }
}* _ptr_impl;
void __decrement()
@@ -196,8 +193,7 @@
{
if(is_owner())
{
- static D DELETER = D();
- DELETER(get());
+ D()(get());
_ptr = 0;
}
}
=======================================
--- /trunk/include/mockitopp/detail/util/tr1_tuple.hpp Mon Sep 19 17:11:06
2011
+++ /trunk/include/mockitopp/detail/util/tr1_tuple.hpp Sat Sep 29 00:40:54
2012
@@ -21,15 +21,7 @@
{
namespace tr1
{
- struct tuple_null_type
- {
- bool operator== (const tuple_null_type&) const { return true; }
- bool operator!= (const tuple_null_type&) const { return false;
}
- bool operator< (const tuple_null_type&) const { return false;
}
- bool operator<= (const tuple_null_type&) const { return true; }
- bool operator> (const tuple_null_type&) const { return false;
}
- bool operator>= (const tuple_null_type&) const { return true; }
- };
+ struct tuple_null_type {};
template <typename H, typename T>
struct tuple_cons
@@ -43,32 +35,6 @@
, tail_(tail)
{}
};
-
- // TODO: fix comparison ops?
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator== (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ == rhs.head_) && (lhs.tail_ == rhs.tail_);
}
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator!= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return !(lhs == rhs); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator< (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ < rhs.head_) || (lhs.tail_ < rhs.tail_); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator<= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs == rhs) || (lhs < rhs); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator> (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ > rhs.head_) && (lhs.tail_ > rhs.tail_); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator>= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs == rhs) || (lhs > rhs); }
// 10 element template
template <typename T0 = tuple_null_type, typename T1 =
tuple_null_type, typename T2 = tuple_null_type, typename T3 =
tuple_null_type, typename T4 = tuple_null_type, typename T5 =
tuple_null_type, typename T6 = tuple_null_type, typename T7 =
tuple_null_type, typename T8 = tuple_null_type, typename T9 =
tuple_null_type>
@@ -204,5 +170,36 @@
} // namespace tr1
} // namespace detail
} // namespace mockitopp
+
+inline bool operator== (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+inline bool operator!= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator< (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator<= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+inline bool operator> (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator>= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator== (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ == rhs.head_) && (lhs.tail_ == rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator!= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return !(lhs == rhs); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator< (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ < rhs.head_) || (lhs.tail_ < rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator<= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs == rhs) || (lhs < rhs); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator> (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ > rhs.head_) && (lhs.tail_ > rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator>= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs == rhs) || (lhs > rhs); }
#endif //__MOCKITOPP_TR1_TUPLE_HPP__
=======================================
--- /trunk/include/mockitopp/detail/util/tr1_tuple.hpp.m4 Mon Sep 19
17:11:06 2011
+++ /trunk/include/mockitopp/detail/util/tr1_tuple.hpp.m4 Sat Sep 29
00:40:54 2012
@@ -26,15 +26,7 @@
{
namespace tr1
{
- struct tuple_null_type
- {
- bool operator== (const tuple_null_type&) const { return true; }
- bool operator!= (const tuple_null_type&) const { return false;
}
- bool operator< (const tuple_null_type&) const { return false;
}
- bool operator<= (const tuple_null_type&) const { return true; }
- bool operator> (const tuple_null_type&) const { return false;
}
- bool operator>= (const tuple_null_type&) const { return true; }
- };
+ struct tuple_null_type {};
template <typename H, typename T>
struct tuple_cons
@@ -48,32 +40,6 @@
, tail_(tail)
{}
};
-
- // TODO: fix comparison ops?
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator== (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ == rhs.head_) && (lhs.tail_ == rhs.tail_);
}
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator!= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return !(lhs == rhs); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator< (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ < rhs.head_) || (lhs.tail_ < rhs.tail_); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator<= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs == rhs) || (lhs < rhs); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator> (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs.head_ > rhs.head_) && (lhs.tail_ > rhs.tail_); }
-
- template <typename L0, typename L1, typename R0, typename R1>
- bool operator>= (const tuple_cons<L0, L1>& lhs, const
tuple_cons<R0, R1>& rhs)
- { return (lhs == rhs) || (lhs > rhs); }
// MOCKITOPP_MAX_VIRTUAL_FUNCTION_ARITY element template
template
<M4_ENUM_BINARY_PARAMS(MOCKITOPP_MAX_VIRTUAL_FUNCTION_ARITY, typename T, =
tuple_null_type, M4_INTERCEPT)>
@@ -117,5 +83,36 @@
} // namespace tr1
} // namespace detail
} // namespace mockitopp
+
+inline bool operator== (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+inline bool operator!= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator< (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator<= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+inline bool operator> (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return false; }
+inline bool operator>= (const mockitopp::detail::tr1::tuple_null_type&,
const mockitopp::detail::tr1::tuple_null_type&) { return true; }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator== (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ == rhs.head_) && (lhs.tail_ == rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator!= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return !(lhs == rhs); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator< (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ < rhs.head_) || (lhs.tail_ < rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator<= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs == rhs) || (lhs < rhs); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator> (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs.head_ > rhs.head_) && (lhs.tail_ > rhs.tail_); }
+
+template <typename L0, typename L1, typename R0, typename R1>
+inline bool operator>= (const mockitopp::detail::tr1::tuple_cons<L0, L1>&
lhs, const mockitopp::detail::tr1::tuple_cons<R0, R1>& rhs)
+ { return (lhs == rhs) || (lhs > rhs); }
#endif //__MOCKITOPP_TR1_TUPLE_HPP__
=======================================
--- /trunk/include/mockitopp/exceptions.hpp Sat Aug 15 15:20:09 2009
+++ /trunk/include/mockitopp/exceptions.hpp Sat Sep 29 00:40:54 2012
@@ -5,17 +5,16 @@
namespace mockitopp
{
- struct partial_implementation_exception : public ::std::exception
- {
- const char *what() const throw()
- { return "function has partial implementation!"; }
- };
+ #define MOCKITO_EXCEPTION(EEE) struct EEE : public ::std::exception {};
- struct missing_implementation_exception : public ::std::exception
- {
- const char *what() const throw()
- { return "function has no implementation!"; }
- };
+ MOCKITO_EXCEPTION(partial_implementation_exception)
+ MOCKITO_EXCEPTION(missing_implementation_exception)
+
+ MOCKITO_EXCEPTION(less_invocations_expected);
+ MOCKITO_EXCEPTION(more_invocations_expected);
+ MOCKITO_EXCEPTION(zero_invocations_expected);
+
+ #undef MOCKITO_EXCEPTION
} // namespace mockitopp
#endif //__MOCKITOPP_EXCEPTIONS_HPP__
=======================================
--- /trunk/include/mockitopp/mock_object.hpp Fri Dec 10 16:59:15 2010
+++ /trunk/include/mockitopp/mock_object.hpp Sat Sep 29 00:40:54 2012
@@ -25,7 +25,10 @@
* @return mock object
*/
T& getInstance()
- { return reinterpret_cast<T&>(*this); }
+ {
+ vtable_ptr = (vtable*) (((char*) vtable_ptr) + sizeof(void*) * 4);
+ return reinterpret_cast<T&>(*this);
+ }
/**
* stub functionality for a given method
=======================================
--- /trunk/test/SConscript Fri Oct 7 23:33:10 2011
+++ /trunk/test/SConscript Sat Sep 29 00:40:54 2012
@@ -41,6 +41,8 @@
'src/test_multiple_inheritance.cpp',
'src/test_overloaded_functions.cpp',
'src/test_verify.cpp',
+ 'src/bugs/issue_7.cpp',
+ 'src/bugs/issue_8.cpp',
'src/compiler/alignment.cpp',
'src/compiler/pointer_size.cpp',
'src/matchers/test_any.cpp',
Reply all
Reply to author
Forward
0 new messages