1.1 --- a/sourcehook/sourcehook.cpp Fri Apr 29 20:29:46 2005 +0000
1.2 +++ b/sourcehook/sourcehook.cpp Sat Apr 30 15:48:46 2005 +0000
1.3 @@ -212,12 +212,17 @@
1.4 hookman->vfnptrs.push_back(vfp);
1.5
1.6 // Alter vtable entry
1.7 - SetMemAccess(cur_vtptr, sizeof(void*) * tmp.vtbl_idx, SH_MEM_READ | SH_MEM_WRITE);
1.8 + SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.vtbl_idx + 1), SH_MEM_READ | SH_MEM_WRITE);
1.9 *reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->hookfunc_vfnptr);
1.10
1.11 // Make vfnptr_iter point to the new element
1.12 vfnptr_iter = hookman->vfnptrs.end();
1.13 --vfnptr_iter;
1.14 +
1.15 + // Now that it is done, check whether we have to update any callclasses
1.16 + for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
1.17 + if (cciter->cc.ptr == iface)
1.18 + ApplyCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx, vfnptr_iter->orig_entry);
1.19 }
1.20
1.21 HookManagerInfo::VfnPtr::IfaceListIter iface_iter = std::find(
1.22 @@ -245,18 +250,6 @@
1.23 iface_iter->hooks_pre.push_back(hookinfo);
1.24
1.25
1.26 - // Now that it is done, check whether we have to update any callclasses
1.27 - for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
1.28 - {
1.29 - if (cciter->cc.ptr == iface)
1.30 - {
1.31 - ApplyCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx, vfnptr_iter->orig_entry);
1.32 -
1.33 - // We can assume that there is no more callclass for the same iface
1.34 - break;
1.35 - }
1.36 - }
1.37 -
1.38 return true;
1.39 }
1.40
1.41 @@ -316,11 +309,17 @@
1.42
1.43 hookman->vfnptrs.erase(vfnptr_iter);
1.44
1.45 + // Remove callclass patch
1.46 + for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
1.47 + if (cciter->cc.ptr == adjustediface)
1.48 + RemoveCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx);
1.49 +
1.50 if (hookman->vfnptrs.empty())
1.51 {
1.52 // Unregister the hook manager
1.53 hookman->func(HA_Unregister, NULL);
1.54 }
1.55 +
1.56 }
1.57 }
1.58 }
1.59 @@ -376,6 +375,28 @@
1.60 tmpvec[vtbl_idx] = orig_entry;
1.61 }
1.62
1.63 + void CSourceHookImpl::RemoveCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx)
1.64 + {
1.65 + OrigVTables::iterator iter = cc.cc.vt.find(vtbl_offs);
1.66 + if (iter != cc.cc.vt.end())
1.67 + {
1.68 + if (iter->second.size() > (size_t)vtbl_idx)
1.69 + {
1.70 + iter->second[vtbl_idx] = 0;
1.71 + // Free some memory if possible
1.72 + OrigFuncs::reverse_iterator riter;
1.73 + for (riter = iter->second.rbegin(); riter != iter->second.rend(); ++riter)
1.74 + {
1.75 + if (*riter != 0)
1.76 + break;
1.77 + }
1.78 + iter->second.resize(iter->second.size() - (riter - iter->second.rbegin()));
1.79 + if (!iter->second.size())
1.80 + cc.cc.vt.erase(iter);
1.81 + }
1.82 + }
1.83 + }
1.84 +
1.85 CSourceHookImpl::HookManInfoList::iterator CSourceHookImpl::FindHookMan(HookManInfoList::iterator begin,
1.86 HookManInfoList::iterator end, const char *proto, int vtblofs, int vtblidx)
1.87 {
2.1 --- a/sourcehook/sourcehook_impl.h Fri Apr 29 20:29:46 2005 +0000
2.2 +++ b/sourcehook/sourcehook_impl.h Sat Apr 30 15:48:46 2005 +0000
2.3 @@ -70,6 +70,7 @@
2.4 const char *proto, int vtblofs, int vtblidx);
2.5
2.6 void ApplyCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx, void *orig_entry);
2.7 + void RemoveCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx);
2.8
2.9 META_RES m_Status, m_PrevRes, m_CurRes;
2.10 const void *m_OrigRet;
3.1 --- a/sourcehook/test/main.cpp Fri Apr 29 20:29:46 2005 +0000
3.2 +++ b/sourcehook/test/main.cpp Sat Apr 30 15:48:46 2005 +0000
3.3 @@ -3,498 +3,72 @@
3.4
3.5 #include <stdio.h>
3.6 #include <iostream>
3.7 -#include "sourcehook_impl.h"
3.8 -#include "FastDelegate.h"
3.9 +#include <string>
3.10 +#include <list>
3.11
3.12 -// Many base classes!
3.13 -struct Base00
3.14 -{
3.15 - int x0;
3.16 - virtual void LOL2(){
3.17 - }
3.18 -};
3.19 -struct Base0
3.20 -{
3.21 - int x0;
3.22 - virtual void LOL(){
3.23 - }
3.24 -};
3.25 -struct Base1 : Base0, Base00
3.26 -{
3.27 - int x;
3.28 - virtual void Func1(){}
3.29 -};
3.30 +using namespace std;
3.31
3.32 -struct Base2 : Base1
3.33 -{
3.34 - int y;
3.35 - virtual void Func2(){}
3.36 -};
3.37 -
3.38 -struct Base3 : Base1
3.39 +class Test
3.40 {
3.41 - int z;
3.42 - virtual void Func3(){}
3.43 -};
3.44 + typedef bool (*TestProto)(std::string&);
3.45 + TestProto m_Func;
3.46 + std::string m_Name;
3.47
3.48 -// Now the main class follows!
3.49 -// Why so many functions?
3.50 -// So we can check the sh_memfuncinfo.h file's correctness
3.51 -// F16 and F299 are actually used
3.52 -// (I've written this by hand, it was fun)
3.53 -class Test : public Base2, public Base3
3.54 -{
3.55 + static std::list<Test *> ms_Tests;
3.56 public:
3.57 - virtual void F1(){}
3.58 - virtual void F2(){}
3.59 - virtual void F3(){}
3.60 - virtual void F4(){}
3.61 - virtual void F5(){}
3.62 - virtual void F6(){}
3.63 - virtual void F7(){}
3.64 - virtual void F8(){}
3.65 - virtual void F9(){}
3.66 - virtual void F10(){}
3.67 - virtual void F11(){}
3.68 - virtual void F12(){}
3.69 - virtual void F13(){}
3.70 - virtual void F14(){}
3.71 - virtual void F15(){}
3.72 - virtual bool F16(int x) { printf("Test::F16[0] called with x=%d; returning false\n", x); return false;}
3.73 - virtual bool F16(const char *x, ...)
3.74 + Test(TestProto func, const char *name) : m_Func(func), m_Name(name)
3.75 {
3.76 - char buf[4096];
3.77 - va_list argptr;
3.78 - va_start(argptr, x);
3.79 - vsprintf(buf, x, argptr);
3.80 - va_end(argptr);
3.81 - printf("Test::F16[1] called with o=%s; returning false\n", buf); return false;
3.82 + ms_Tests.push_back(this);
3.83 }
3.84 - virtual void F17(){}
3.85 - virtual void F18(){}
3.86 - virtual void F19(){}
3.87 - virtual void F20(){}
3.88 - virtual void F21(){}
3.89 - virtual void F22(){}
3.90 - virtual void F23(){}
3.91 - virtual void F24(){}
3.92 - virtual void F25(){}
3.93 - virtual void F26(){}
3.94 - virtual void F27(){}
3.95 - virtual void F28(){}
3.96 - virtual void F29(){}
3.97 - virtual void F30(){}
3.98 - virtual void F31(){}
3.99 - virtual void F32(){}
3.100 - virtual void F33(){}
3.101 - virtual void F34(){}
3.102 - virtual void F35(){}
3.103 - virtual void F36(){}
3.104 - virtual void F37(){}
3.105 - virtual void F38(){}
3.106 - virtual void F39(){}
3.107 - virtual void F40(){}
3.108 - virtual void F41(){}
3.109 - virtual void F42(){}
3.110 - virtual void F43(){}
3.111 - virtual void F44(){}
3.112 - virtual void F45(){}
3.113 - virtual void F46(){}
3.114 - virtual void F47(){}
3.115 - virtual void F48(){}
3.116 - virtual void F49(){}
3.117 - virtual void F50(){}
3.118 - virtual void F51(){}
3.119 - virtual void F52(){}
3.120 - virtual void F53(){}
3.121 - virtual void F54(){}
3.122 - virtual void F55(){}
3.123 - virtual void F56(){}
3.124 - virtual void F57(){}
3.125 - virtual void F58(){}
3.126 - virtual void F59(){}
3.127 - virtual void F60(){}
3.128 - virtual void F61(){}
3.129 - virtual void F62(){}
3.130 - virtual void F63(){}
3.131 - virtual void F64(){}
3.132 - virtual void F65(){}
3.133 - virtual void F66(){}
3.134 - virtual void F67(){}
3.135 - virtual void F68(){}
3.136 - virtual void F69(){}
3.137 - virtual void F70(){}
3.138 - virtual void F71(){}
3.139 - virtual void F72(){}
3.140 - virtual void F73(){}
3.141 - virtual void F74(){}
3.142 - virtual void F75(){}
3.143 - virtual void F76(){}
3.144 - virtual void F77(){}
3.145 - virtual void F78(){}
3.146 - virtual void F79(){}
3.147 - virtual void F80(){}
3.148 - virtual void F81(){}
3.149 - virtual void F82(){}
3.150 - virtual void F83(){}
3.151 - virtual void F84(){}
3.152 - virtual void F85(){}
3.153 - virtual void F86(){}
3.154 - virtual void F87(){}
3.155 - virtual void F88(){}
3.156 - virtual void F89(){}
3.157 - virtual void F90(){}
3.158 - virtual void F91(){}
3.159 - virtual void F92(){}
3.160 - virtual void F93(){}
3.161 - virtual void F94(){}
3.162 - virtual void F95(){}
3.163 - virtual void F96(){}
3.164 - virtual void F97(){}
3.165 - virtual void F98(){}
3.166 - virtual void F99(){}
3.167 - virtual void F100(){}
3.168 - virtual void F101(){}
3.169 - virtual void F102(){}
3.170 - virtual void F103(){}
3.171 - virtual void F104(){}
3.172 - virtual void F105(){}
3.173 - virtual void F106(){}
3.174 - virtual void F107(){}
3.175 - virtual void F108(){}
3.176 - virtual void F109(){}
3.177 - virtual void F110(){}
3.178 - virtual void F111(){}
3.179 - virtual void F112(){}
3.180 - virtual void F113(){}
3.181 - virtual void F114(){}
3.182 - virtual void F115(){}
3.183 - virtual void F116(){}
3.184 - virtual void F117(){}
3.185 - virtual void F118(){}
3.186 - virtual void F119(){}
3.187 - virtual void F120(){}
3.188 - virtual void F121(){}
3.189 - virtual void F122(){}
3.190 - virtual void F123(){}
3.191 - virtual void F124(){}
3.192 - virtual void F125(){}
3.193 - virtual void F126(){}
3.194 - virtual void F127(){}
3.195 - virtual void F128(){}
3.196 - virtual void F129(){}
3.197 - virtual void F130(){}
3.198 - virtual void F131(){}
3.199 - virtual void F132(){}
3.200 - virtual void F133(){}
3.201 - virtual void F134(){}
3.202 - virtual void F135(){}
3.203 - virtual void F136(){}
3.204 - virtual void F137(){}
3.205 - virtual void F138(){}
3.206 - virtual void F139(){}
3.207 - virtual void F140(){}
3.208 - virtual void F141(){}
3.209 - virtual void F142(){}
3.210 - virtual void F143(){}
3.211 - virtual void F144(){}
3.212 - virtual void F145(){}
3.213 - virtual void F146(){}
3.214 - virtual void F147(){}
3.215 - virtual void F148(){}
3.216 - virtual void F149(){}
3.217 - virtual void F150(){}
3.218 - virtual void F151(){}
3.219 - virtual void F152(){}
3.220 - virtual void F153(){}
3.221 - virtual void F154(){}
3.222 - virtual void F155(){}
3.223 - virtual void F156(){}
3.224 - virtual void F157(){}
3.225 - virtual void F158(){}
3.226 - virtual void F159(){}
3.227 - virtual void F160(){}
3.228 - virtual void F161(){}
3.229 - virtual void F162(){}
3.230 - virtual void F163(){}
3.231 - virtual void F164(){}
3.232 - virtual void F165(){}
3.233 - virtual void F166(){}
3.234 - virtual void F167(){}
3.235 - virtual void F168(){}
3.236 - virtual void F169(){}
3.237 - virtual void F170(){}
3.238 - virtual void F171(){}
3.239 - virtual void F172(){}
3.240 - virtual void F173(){}
3.241 - virtual void F174(){}
3.242 - virtual void F175(){}
3.243 - virtual void F176(){}
3.244 - virtual void F177(){}
3.245 - virtual void F178(){}
3.246 - virtual void F179(){}
3.247 - virtual void F180(){}
3.248 - virtual void F181(){}
3.249 - virtual void F182(){}
3.250 - virtual void F183(){}
3.251 - virtual void F184(){}
3.252 - virtual void F185(){}
3.253 - virtual void F186(){}
3.254 - virtual void F187(){}
3.255 - virtual void F188(){}
3.256 - virtual void F189(){}
3.257 - virtual void F190(){}
3.258 - virtual void F191(){}
3.259 - virtual void F192(){}
3.260 - virtual void F193(){}
3.261 - virtual void F194(){}
3.262 - virtual void F195(){}
3.263 - virtual void F196(){}
3.264 - virtual void F197(){}
3.265 - virtual void F198(){}
3.266 - virtual void F199(){}
3.267 - virtual void F200(){}
3.268 - virtual void F201(){}
3.269 - virtual void F202(){}
3.270 - virtual void F203(){}
3.271 - virtual void F204(){}
3.272 - virtual void F205(){}
3.273 - virtual void F206(){}
3.274 - virtual void F207(){}
3.275 - virtual void F208(){}
3.276 - virtual void F209(){}
3.277 - virtual void F210(){}
3.278 - virtual void F211(){}
3.279 - virtual void F212(){}
3.280 - virtual void F213(){}
3.281 - virtual void F214(){}
3.282 - virtual void F215(){}
3.283 - virtual void F216(){}
3.284 - virtual void F217(){}
3.285 - virtual void F218(){}
3.286 - virtual void F219(){}
3.287 - virtual void F220(){}
3.288 - virtual void F221(){}
3.289 - virtual void F222(){}
3.290 - virtual void F223(){}
3.291 - virtual void F224(){}
3.292 - virtual void F225(){}
3.293 - virtual void F226(){}
3.294 - virtual void F227(){}
3.295 - virtual void F228(){}
3.296 - virtual void F229(){}
3.297 - virtual void F230(){}
3.298 - virtual void F231(){}
3.299 - virtual void F232(){}
3.300 - virtual void F233(){}
3.301 - virtual void F234(){}
3.302 - virtual void F235(){}
3.303 - virtual void F236(){}
3.304 - virtual void F237(){}
3.305 - virtual void F238(){}
3.306 - virtual void F239(){}
3.307 - virtual void F240(){}
3.308 - virtual void F241(){}
3.309 - virtual void F242(){}
3.310 - virtual void F243(){}
3.311 - virtual void F244(){}
3.312 - virtual void F245(){}
3.313 - virtual void F246(){}
3.314 - virtual void F247(){}
3.315 - virtual void F248(){}
3.316 - virtual void F249(){}
3.317 - virtual void F250(){}
3.318 - virtual void F251(){}
3.319 - virtual void F252(){}
3.320 - virtual void F253(){}
3.321 - virtual void F254(){}
3.322 - virtual void F255(){}
3.323 - virtual void F256(){}
3.324 - virtual void F257(){}
3.325 - virtual void F258(){}
3.326 - virtual void F259(){}
3.327 - virtual void F260(){}
3.328 - virtual void F261(){}
3.329 - virtual void F262(){}
3.330 - virtual void F263(){}
3.331 - virtual void F264(){}
3.332 - virtual void F265(){}
3.333 - virtual void F266(){}
3.334 - virtual void F267(){}
3.335 - virtual void F268(){}
3.336 - virtual void F269(){}
3.337 - virtual void F270(){}
3.338 - virtual void F271(){}
3.339 - virtual void F272(){}
3.340 - virtual void F273(){}
3.341 - virtual void F274(){}
3.342 - virtual void F275(){}
3.343 - virtual void F276(){}
3.344 - virtual void F277(){}
3.345 - virtual void F278(){}
3.346 - virtual void F279(){}
3.347 - virtual void F280(){}
3.348 - virtual void F281(){}
3.349 - virtual void F282(){}
3.350 - virtual void F283(){}
3.351 - virtual void F284(){}
3.352 - virtual void F285(){}
3.353 - virtual void F286(){}
3.354 - virtual void F287(){}
3.355 - virtual void F288(){}
3.356 - virtual void F289(){}
3.357 - virtual void F290(){}
3.358 - virtual void F291(){}
3.359 - virtual void F292(){}
3.360 - virtual void F293(){}
3.361 - virtual void F294(){}
3.362 - virtual void F295(){}
3.363 - virtual void F296(){}
3.364 - virtual void F297(){}
3.365 - virtual void F298(){}
3.366 - virtual void F299(){ printf("Test::F299 was called. this=%p\n", this); }
3.367
3.368 - void G() {
3.369 + bool operator()()
3.370 + {
3.371 + std::string error;
3.372 + if (!m_Func(error))
3.373 + {
3.374 + cout << "Test" << m_Name << " FAILED: " << error << endl;
3.375 + return false;
3.376 + }
3.377 + else
3.378 + {
3.379 + cout << "Test" << m_Name << " passed" << endl;
3.380 + return true;
3.381 + }
3.382 + }
3.383 +
3.384 + static void DoTests()
3.385 + {
3.386 + int passed=0, failed=0;
3.387 + for (std::list<Test*>::iterator iter = ms_Tests.begin(); iter != ms_Tests.end(); ++iter)
3.388 + {
3.389 + if ((**iter)())
3.390 + ++passed;
3.391 + else
3.392 + ++failed;
3.393 +
3.394 + cout << endl << "----" << endl << "Passed: " << passed << endl << "Failed: " << failed << endl;
3.395 + cout << "Total: " << passed + failed << endl;
3.396 + }
3.397 }
3.398 };
3.399
3.400 -// Sourcehook needs g_Plug and g_SHPtr, it will be customizable in the next release
3.401 -int g_PLID = 1337;
3.402 -SourceHook::ISourceHook *g_SHPtr;
3.403 -
3.404 -SourceHook::CSourceHookImpl g_SHImpl;
3.405 -
3.406 -// You first have to declare the hook functions
3.407 -SH_DECL_HOOK0_void(Test, F299, SH_NOATTRIB, 0);
3.408 -
3.409 -// Test of overloaded functions
3.410 -SH_DECL_HOOK1(Test, F16, SH_NOATTRIB, 0, bool, int);
3.411 -SH_DECL_HOOK0_vafmt(Test, F16, SH_NOATTRIB, 1, bool);
3.412 -
3.413 -
3.414 -// Handlers for F299
3.415 -void Test_F299_pre_handler()
3.416 -{
3.417 - printf("Pre hook handler for Test:F299 called. This=%p; ignoring\n", META_IFACEPTR);
3.418 -}
3.419 +std::list<Test *> Test::ms_Tests;
3.420
3.421 -void Test_F299_pre_handler2()
3.422 -{
3.423 - printf("Pre hook handler for Test:F299 called. This=%p; superceding\n", META_IFACEPTR);
3.424 - RETURN_META(MRES_SUPERCEDE);
3.425 -}
3.426 -
3.427 -void Test_F299_post_handler()
3.428 -{
3.429 - printf("Post hook handler for Test:F299 called. This=%p; ignoring\n", META_IFACEPTR);
3.430 -}
3.431 +#define DO_TEST(x) \
3.432 + bool Test##x(std::string &error); \
3.433 + Test g_Test##x(Test##x, #x);
3.434
3.435 -// Handlers for F16
3.436 -bool Test_F16_int_pre_handler(int x)
3.437 -{
3.438 - printf("Pre hook handler for Test::F16 called. x=%d, this=%p; superceding with true\n", x, META_IFACEPTR);
3.439 - RETURN_META_VALUE(MRES_SUPERCEDE, true);
3.440 -}
3.441 -
3.442 -bool Test_F16_int_post_handler(int x)
3.443 -{
3.444 - printf("Post hook handler for Test::F16(int) called. x=%d, this=%p, status=%d, orig ret=%d; overriding with !ret\n", x, META_IFACEPTR, META_RESULT_STATUS, META_RESULT_ORIG_RET(bool) ? 1 : 0);
3.445 - RETURN_META_VALUE(MRES_OVERRIDE, !META_RESULT_ORIG_RET(bool));
3.446 -}
3.447 +DO_TEST(Basic);
3.448
3.449 int main(int argc, char *argv[])
3.450 {
3.451 - // Get an instance and call the functions using the pointer
3.452 - // (otherwise the compiler optimizes away the vtable lookup)
3.453 - Test zLOL;
3.454 - Test zLOL2;
3.455 - Test *zLOL_Ptr = &zLOL;
3.456 - Test *zLOL2_Ptr = &zLOL2;
3.457 - g_SHPtr = &g_SHImpl;
3.458 -
3.459 - //////////////////////////////////////////////////////////////////////////
3.460 - SourceHook::CallClass<Test> *cc = SH_GET_CALLCLASS(zLOL_Ptr);
3.461 + std::string error;
3.462 + int passed=0, failed=0;
3.463
3.464 - printf("TEST1.1: Calling F299\n");
3.465 - zLOL_Ptr->F299();
3.466 - printf("TEST1.2: Calling F299 through cc\n");
3.467 - SH_CALL(cc, &Test::F299)();
3.468 - printf("TEST1.3: Hooking it\n");
3.469 - SH_ADD_HOOK_STATICFUNC(Test, F299, zLOL_Ptr, Test_F299_pre_handler, false);
3.470 - zLOL2_Ptr->F299();
3.471 - printf("TEST1.4: Calling F299\n");
3.472 - zLOL_Ptr->F299();
3.473 - printf("TEST1.5: Calling F299 through cc\n");
3.474 - SH_CALL(cc, &Test::F299)();
3.475 - printf("TEST1.6: Adding one more pre and one post hook\n");
3.476 - SH_ADD_HOOK_STATICFUNC(Test, F299, zLOL_Ptr, Test_F299_pre_handler2, false);
3.477 - SH_ADD_HOOK_STATICFUNC(Test, F299, zLOL_Ptr, Test_F299_post_handler, true);
3.478 - printf("TEST1.7: Calling F299\n");
3.479 - zLOL_Ptr->F299();
3.480 - printf("TEST1.8: Calling F299 through cc\n");
3.481 - SH_CALL(cc, &Test::F299)();
3.482 - printf("TEST1.9: Removing pre hooks\n");
3.483 - SH_REMOVE_HOOK_STATICFUNC(Test, F299, zLOL_Ptr, Test_F299_pre_handler, false);
3.484 - SH_REMOVE_HOOK_STATICFUNC(Test, F299, zLOL_Ptr, Test_F299_pre_handler2, false);
3.485 - printf("TEST1.10: Calling F299\n");
3.486 - zLOL_Ptr->F299();
3.487 - printf("TEST1.11: Calling F299 through cc\n");
3.488 - SH_CALL(cc, &Test::F299)();
3.489 - printf("TEST1.12: Removing post hook\n");
3.490 - SH_REMOVE_HOOK_STATICFUNC(Test, F299, zLOL_Ptr, Test_F299_post_handler, true);
3.491 - printf("TEST1.13: Calling F299\n");
3.492 - zLOL_Ptr->F299();
3.493 - printf("TEST1.14: Calling F299 through cc\n");
3.494 - SH_CALL(cc, &Test::F299)();
3.495 + Test::DoTests();
3.496
3.497 - //////////////////////////////////////////////////////////////////////////
3.498 - printf("\n\n*************************************************\n\n");
3.499 - printf("TEST2.1: Calling F16(155)\n");
3.500 - printf("Returned: %d\n", zLOL_Ptr->F16(155) ? 1 : 0);
3.501 - printf("TEST2.2: Calling F16(155) through CC\n");
3.502 - printf("Returned: %d\n", SH_CALL(cc, static_cast<bool(Test::*)(int)>(&Test::F16))(155) ? 1 : 0);
3.503 - printf("TEST2.3: Hooking it\n");
3.504 - SH_ADD_HOOK_STATICFUNC(Test, F16, zLOL_Ptr, Test_F16_int_pre_handler, false);
3.505 - printf("TEST2.4: Calling F16(155)\n");
3.506 - printf("Returned: %d\n", zLOL_Ptr->F16(155) ? 1 : 0);
3.507 - printf("TEST2.5: Calling F16(155) through CC\n");
3.508 - printf("Returned: %d\n", SH_CALL(cc, static_cast<bool(Test::*)(int)>(&Test::F16))(155) ? 1 : 0);
3.509 - printf("TEST2.6: Adding post hook\n");
3.510 - SH_ADD_HOOK_STATICFUNC(Test, F16, zLOL_Ptr, Test_F16_int_post_handler, true);
3.511 - printf("TEST2.7: Calling F16(155)\n");
3.512 - printf("Returned: %d\n", zLOL_Ptr->F16(155) ? 1 : 0);
3.513 - printf("TEST2.8: Calling F16(155) through CC\n");
3.514 - printf("Returned: %d\n", SH_CALL(cc, static_cast<bool(Test::*)(int)>(&Test::F16))(155) ? 1 : 0);
3.515 - printf("TEST2.XX.1: Pausing the plugin\n");
3.516 - g_SHImpl.PausePlugin(g_PLID);
3.517 - printf("TEST2.XX.2: Calling F16(155)\n");
3.518 - printf("Returned: %d\n", zLOL_Ptr->F16(155) ? 1 : 0);
3.519 - printf("TEST2.XX.3: Calling F16(155) through CC\n");
3.520 - printf("Returned: %d\n", SH_CALL(cc, static_cast<bool(Test::*)(int)>(&Test::F16))(155) ? 1 : 0);
3.521 - printf("TEST2.XX.4: Unpausing the plugin\n");
3.522 - g_SHImpl.UnpausePlugin(g_PLID);
3.523 - printf("TEST2.XX.5: Calling F16(155)\n");
3.524 - printf("Returned: %d\n", zLOL_Ptr->F16(155) ? 1 : 0);
3.525 - printf("TEST2.XX.6: Calling F16(155) through CC\n");
3.526 - printf("Returned: %d\n", SH_CALL(cc, static_cast<bool(Test::*)(int)>(&Test::F16))(155) ? 1 : 0);
3.527 - printf("TEST2.9: Removing pre hook\n");
3.528 - SH_REMOVE_HOOK_STATICFUNC(Test, F16, zLOL_Ptr, Test_F16_int_pre_handler, false);
3.529 - printf("TEST2.10: Calling F16(155)\n");
3.530 - printf("Returned: %d\n", zLOL_Ptr->F16(155) ? 1 : 0);
3.531 - printf("TEST2.11: Calling F16(155) through CC\n");
3.532 - printf("Returned: %d\n", SH_CALL(cc, static_cast<bool(Test::*)(int)>(&Test::F16))(155) ? 1 : 0);
3.533 - printf("TEST2.12: Removing post hook\n");
3.534 - SH_REMOVE_HOOK_STATICFUNC(Test, F16, zLOL_Ptr, Test_F16_int_post_handler, true);
3.535 - printf("TEST2.10: Calling F16(155)\n");
3.536 - printf("Returned: %d\n", zLOL_Ptr->F16(155) ? 1 : 0);
3.537 - printf("TEST2.11: Calling F16(155) through CC\n");
3.538 - printf("Returned: %d\n", SH_CALL(cc, static_cast<bool(Test::*)(int)>(&Test::F16))(155) ? 1 : 0);
3.539 + cout << "Press enter to continue" << endl;
3.540
3.541 - SH_RELEASE_CALLCLASS(cc);
3.542 -
3.543 - // Type 0[ENTER] so that the program terminates
3.544 - int i;
3.545 - std::cin >> i;
3.546 -}
3.547 -
3.548 -// That is it, dear BAIL!
3.549 \ No newline at end of file
3.550 + char x;
3.551 + cin.read(&x, 1);
3.552 +}
3.553 \ No newline at end of file
4.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
4.2 +++ b/sourcehook/test/test1.cpp Sat Apr 30 15:48:46 2005 +0000
4.3 @@ -0,0 +1,702 @@
4.4 +#include <string>
4.5 +#include "sourcehook_impl.h"
4.6 +#include "testevents.h"
4.7 +
4.8 +// Global to all tests
4.9 +SourceHook::ISourceHook *g_SHPtr;
4.10 +SourceHook::Plugin g_PLID;
4.11 +
4.12 +// TEST1
4.13 +// Basic tests
4.14 +// Hooking and callclass
4.15 +
4.16 +
4.17 +struct State_F1_Called : State
4.18 +{
4.19 +};
4.20 +
4.21 +struct State_F1_PreHandler_Called : State
4.22 +{
4.23 +};
4.24 +
4.25 +struct State_F1_PostHandler_Called : State
4.26 +{
4.27 +};
4.28 +
4.29 +struct State_F1_HookAdded : State
4.30 +{
4.31 + bool m_Successfully;
4.32 + State_F1_HookAdded(bool successfully) : m_Successfully(successfully)
4.33 + {
4.34 + }
4.35 +
4.36 + bool IsEqual(State *other)
4.37 + {
4.38 + State_F1_HookAdded *other2 = dynamic_cast<State_F1_HookAdded*>(other);
4.39 + if (!other2)
4.40 + return false;
4.41 + return other2->m_Successfully == m_Successfully;
4.42 + }
4.43 +};
4.44 +
4.45 +struct State_F1_HookRemoved : State
4.46 +{
4.47 +};
4.48 +
4.49 +struct State_F1_CallClassGenerated : State
4.50 +{
4.51 +};
4.52 +
4.53 +struct State_F1_CallClassReleased : State
4.54 +{
4.55 +};
4.56 +
4.57 +struct State_F299_Called : State
4.58 +{
4.59 + std::string param;
4.60 + State_F299_Called(const char *p) : param(p)
4.61 + {
4.62 + }
4.63 + bool IsEqual(State *other)
4.64 + {
4.65 + State_F299_Called *other2 = dynamic_cast<State_F299_Called*>(other);
4.66 + if (!other2)
4.67 + return false;
4.68 + return other2->param == param;
4.69 + }
4.70 +};
4.71 +
4.72 +struct State_F299_PreHandlerCalled : State_F299_Called
4.73 +{
4.74 + State_F299_PreHandlerCalled(const char *p) : State_F299_Called(p)
4.75 + {
4.76 + }
4.77 +};
4.78 +
4.79 +struct State_F299_PostHandlerCalled : State_F299_Called
4.80 +{
4.81 + State_F299_PostHandlerCalled(const char *p) : State_F299_Called(p)
4.82 + {
4.83 + }
4.84 +};
4.85 +
4.86 +struct State_F299Ret : State
4.87 +{
4.88 + bool m_Ret;
4.89 + State_F299Ret(bool ret) : m_Ret(ret)
4.90 + {
4.91 + }
4.92 +
4.93 + bool IsEqual(State *other)
4.94 + {
4.95 + State_F299Ret *other2 = dynamic_cast<State_F299Ret*>(other);
4.96 + if (!other2)
4.97 + return false;
4.98 + return other2->m_Ret == m_Ret;
4.99 + }
4.100 +};
4.101 +
4.102 +class Test
4.103 +{
4.104 +public:
4.105 + virtual void F1()
4.106 + {
4.107 + ADD_STATE(State_F1_Called);
4.108 + }
4.109 + virtual void F2(){}
4.110 + virtual void F3(){}
4.111 + virtual void F4(){}
4.112 + virtual void F5(){}
4.113 + virtual void F6(){}
4.114 + virtual void F7(){}
4.115 + virtual void F8(){}
4.116 + virtual void F9(){}
4.117 + virtual void F10(){}
4.118 + virtual void F11(){}
4.119 + virtual void F12(){}
4.120 + virtual void F13(){}
4.121 + virtual void F14(){}
4.122 + virtual void F15(){}
4.123 + virtual void F16(){}
4.124 + virtual void F17(){}
4.125 + virtual void F18(){}
4.126 + virtual void F19(){}
4.127 + virtual void F20(){}
4.128 + virtual void F21(){}
4.129 + virtual void F22(){}
4.130 + virtual void F23(){}
4.131 + virtual void F24(){}
4.132 + virtual void F25(){}
4.133 + virtual void F26(){}
4.134 + virtual void F27(){}
4.135 + virtual void F28(){}
4.136 + virtual void F29(){}
4.137 + virtual void F30(){}
4.138 + virtual void F31(){}
4.139 + virtual void F32(){}
4.140 + virtual void F33(){}
4.141 + virtual void F34(){}
4.142 + virtual void F35(){}
4.143 + virtual void F36(){}
4.144 + virtual void F37(){}
4.145 + virtual void F38(){}
4.146 + virtual void F39(){}
4.147 + virtual void F40(){}
4.148 + virtual void F41(){}
4.149 + virtual void F42(){}
4.150 + virtual void F43(){}
4.151 + virtual void F44(){}
4.152 + virtual void F45(){}
4.153 + virtual void F46(){}
4.154 + virtual void F47(){}
4.155 + virtual void F48(){}
4.156 + virtual void F49(){}
4.157 + virtual void F50(){}
4.158 + virtual void F51(){}
4.159 + virtual void F52(){}
4.160 + virtual void F53(){}
4.161 + virtual void F54(){}
4.162 + virtual void F55(){}
4.163 + virtual void F56(){}
4.164 + virtual void F57(){}
4.165 + virtual void F58(){}
4.166 + virtual void F59(){}
4.167 + virtual void F60(){}
4.168 + virtual void F61(){}
4.169 + virtual void F62(){}
4.170 + virtual void F63(){}
4.171 + virtual void F64(){}
4.172 + virtual void F65(){}
4.173 + virtual void F66(){}
4.174 + virtual void F67(){}
4.175 + virtual void F68(){}
4.176 + virtual void F69(){}
4.177 + virtual void F70(){}
4.178 + virtual void F71(){}
4.179 + virtual void F72(){}
4.180 + virtual void F73(){}
4.181 + virtual void F74(){}
4.182 + virtual void F75(){}
4.183 + virtual void F76(){}
4.184 + virtual void F77(){}
4.185 + virtual void F78(){}
4.186 + virtual void F79(){}
4.187 + virtual void F80(){}
4.188 + virtual void F81(){}
4.189 + virtual void F82(){}
4.190 + virtual void F83(){}
4.191 + virtual void F84(){}
4.192 + virtual void F85(){}
4.193 + virtual void F86(){}
4.194 + virtual void F87(){}
4.195 + virtual void F88(){}
4.196 + virtual void F89(){}
4.197 + virtual void F90(){}
4.198 + virtual void F91(){}
4.199 + virtual void F92(){}
4.200 + virtual void F93(){}
4.201 + virtual void F94(){}
4.202 + virtual void F95(){}
4.203 + virtual void F96(){}
4.204 + virtual void F97(){}
4.205 + virtual void F98(){}
4.206 + virtual void F99(){}
4.207 + virtual void F100(){}
4.208 + virtual void F101(){}
4.209 + virtual void F102(){}
4.210 + virtual void F103(){}
4.211 + virtual void F104(){}
4.212 + virtual void F105(){}
4.213 + virtual void F106(){}
4.214 + virtual void F107(){}
4.215 + virtual void F108(){}
4.216 + virtual void F109(){}
4.217 + virtual void F110(){}
4.218 + virtual void F111(){}
4.219 + virtual void F112(){}
4.220 + virtual void F113(){}
4.221 + virtual void F114(){}
4.222 + virtual void F115(){}
4.223 + virtual void F116(){}
4.224 + virtual void F117(){}
4.225 + virtual void F118(){}
4.226 + virtual void F119(){}
4.227 + virtual void F120(){}
4.228 + virtual void F121(){}
4.229 + virtual void F122(){}
4.230 + virtual void F123(){}
4.231 + virtual void F124(){}
4.232 + virtual void F125(){}
4.233 + virtual void F126(){}
4.234 + virtual void F127(){}
4.235 + virtual void F128(){}
4.236 + virtual void F129(){}
4.237 + virtual void F130(){}
4.238 + virtual void F131(){}
4.239 + virtual void F132(){}
4.240 + virtual void F133(){}
4.241 + virtual void F134(){}
4.242 + virtual void F135(){}
4.243 + virtual void F136(){}
4.244 + virtual void F137(){}
4.245 + virtual void F138(){}
4.246 + virtual void F139(){}
4.247 + virtual void F140(){}
4.248 + virtual void F141(){}
4.249 + virtual void F142(){}
4.250 + virtual void F143(){}
4.251 + virtual void F144(){}
4.252 + virtual void F145(){}
4.253 + virtual void F146(){}
4.254 + virtual void F147(){}
4.255 + virtual void F148(){}
4.256 + virtual void F149(){}
4.257 + virtual void F150(){}
4.258 + virtual void F151(){}
4.259 + virtual void F152(){}
4.260 + virtual void F153(){}
4.261 + virtual void F154(){}
4.262 + virtual void F155(){}
4.263 + virtual void F156(){}
4.264 + virtual void F157(){}
4.265 + virtual void F158(){}
4.266 + virtual void F159(){}
4.267 + virtual void F160(){}
4.268 + virtual void F161(){}
4.269 + virtual void F162(){}
4.270 + virtual void F163(){}
4.271 + virtual void F164(){}
4.272 + virtual void F165(){}
4.273 + virtual void F166(){}
4.274 + virtual void F167(){}
4.275 + virtual void F168(){}
4.276 + virtual void F169(){}
4.277 + virtual void F170(){}
4.278 + virtual void F171(){}
4.279 + virtual void F172(){}
4.280 + virtual void F173(){}
4.281 + virtual void F174(){}
4.282 + virtual void F175(){}
4.283 + virtual void F176(){}
4.284 + virtual void F177(){}
4.285 + virtual void F178(){}
4.286 + virtual void F179(){}
4.287 + virtual void F180(){}
4.288 + virtual void F181(){}
4.289 + virtual void F182(){}
4.290 + virtual void F183(){}
4.291 + virtual void F184(){}
4.292 + virtual void F185(){}
4.293 + virtual void F186(){}
4.294 + virtual void F187(){}
4.295 + virtual void F188(){}
4.296 + virtual void F189(){}
4.297 + virtual void F190(){}
4.298 + virtual void F191(){}
4.299 + virtual void F192(){}
4.300 + virtual void F193(){}
4.301 + virtual void F194(){}
4.302 + virtual void F195(){}
4.303 + virtual void F196(){}
4.304 + virtual void F197(){}
4.305 + virtual void F198(){}
4.306 + virtual void F199(){}
4.307 + virtual void F200(){}
4.308 + virtual void F201(){}
4.309 + virtual void F202(){}
4.310 + virtual void F203(){}
4.311 + virtual void F204(){}
4.312 + virtual void F205(){}
4.313 + virtual void F206(){}
4.314 + virtual void F207(){}
4.315 + virtual void F208(){}
4.316 + virtual void F209(){}
4.317 + virtual void F210(){}
4.318 + virtual void F211(){}
4.319 + virtual void F212(){}
4.320 + virtual void F213(){}
4.321 + virtual void F214(){}
4.322 + virtual void F215(){}
4.323 + virtual void F216(){}
4.324 + virtual void F217(){}
4.325 + virtual void F218(){}
4.326 + virtual void F219(){}
4.327 + virtual void F220(){}
4.328 + virtual void F221(){}
4.329 + virtual void F222(){}
4.330 + virtual void F223(){}
4.331 + virtual void F224(){}
4.332 + virtual void F225(){}
4.333 + virtual void F226(){}
4.334 + virtual void F227(){}
4.335 + virtual void F228(){}
4.336 + virtual void F229(){}
4.337 + virtual void F230(){}
4.338 + virtual void F231(){}
4.339 + virtual void F232(){}
4.340 + virtual void F233(){}
4.341 + virtual void F234(){}
4.342 + virtual void F235(){}
4.343 + virtual void F236(){}
4.344 + virtual void F237(){}
4.345 + virtual void F238(){}
4.346 + virtual void F239(){}
4.347 + virtual void F240(){}
4.348 + virtual void F241(){}
4.349 + virtual void F242(){}
4.350 + virtual void F243(){}
4.351 + virtual void F244(){}
4.352 + virtual void F245(){}
4.353 + virtual void F246(){}
4.354 + virtual void F247(){}
4.355 + virtual void F248(){}
4.356 + virtual void F249(){}
4.357 + virtual void F250(){}
4.358 + virtual void F251(){}
4.359 + virtual void F252(){}
4.360 + virtual void F253(){}
4.361 + virtual void F254(){}
4.362 + virtual void F255(){}
4.363 + virtual void F256(){}
4.364 + virtual void F257(){}
4.365 + virtual void F258(){}
4.366 + virtual void F259(){}
4.367 + virtual void F260(){}
4.368 + virtual void F261(){}
4.369 + virtual void F262(){}
4.370 + virtual void F263(){}
4.371 + virtual void F264(){}
4.372 + virtual void F265(){}
4.373 + virtual void F266(){}
4.374 + virtual void F267(){}
4.375 + virtual void F268(){}
4.376 + virtual void F269(){}
4.377 + virtual void F270(){}
4.378 + virtual void F271(){}
4.379 + virtual void F272(){}
4.380 + virtual void F273(){}
4.381 + virtual void F274(){}
4.382 + virtual void F275(){}
4.383 + virtual void F276(){}
4.384 + virtual void F277(){}
4.385 + virtual void F278(){}
4.386 + virtual void F279(){}
4.387 + virtual void F280(){}
4.388 + virtual void F281(){}
4.389 + virtual void F282(){}
4.390 + virtual void F283(){}
4.391 + virtual void F284(){}
4.392 + virtual void F285(){}
4.393 + virtual void F286(){}
4.394 + virtual void F287(){}
4.395 + virtual void F288(){}
4.396 + virtual void F289(){}
4.397 + virtual void F290(){}
4.398 + virtual void F291(){}
4.399 + virtual void F292(){}
4.400 + virtual void F293(){}
4.401 + virtual void F294(){}
4.402 + virtual void F295(){}
4.403 + virtual void F296(){}
4.404 + virtual void F297(){}
4.405 + virtual void F298(){}
4.406 + virtual bool F299(const char *mwah)
4.407 + {
4.408 + ADD_STATE(State_F299_Called(mwah));
4.409 + return true;
4.410 + }
4.411 +};
4.412 +
4.413 +SH_DECL_HOOK0_void(Test, F1, SH_NOATTRIB, 0);
4.414 +SH_DECL_HOOK1(Test, F299, SH_NOATTRIB, 0, bool, const char *);
4.415 +
4.416 +META_RES g_F1Pre_WhatToDo;
4.417 +META_RES g_F1Post_WhatToDo;
4.418 +
4.419 +struct HandlersF1
4.420 +{
4.421 + void Pre()
4.422 + {
4.423 + ADD_STATE(State_F1_PreHandler_Called);
4.424 + RETURN_META(g_F1Pre_WhatToDo);
4.425 + }
4.426 +
4.427 + void Post()
4.428 + {
4.429 + ADD_STATE(State_F1_PostHandler_Called);
4.430 + RETURN_META(g_F1Post_WhatToDo);
4.431 + }
4.432 +};
4.433 +
4.434 +META_RES g_F299Pre_WhatToDo;
4.435 +bool g_F299Pre_WhatToRet;
4.436 +
4.437 +bool F299_Pre(const char *mwah)
4.438 +{
4.439 + ADD_STATE(State_F299_PreHandlerCalled(mwah));
4.440 + RETURN_META_VALUE(g_F299Pre_WhatToDo, g_F299Pre_WhatToRet);
4.441 +}
4.442 +
4.443 +bool F299_Post(const char *mwah)
4.444 +{
4.445 + ADD_STATE(State_F299_PostHandlerCalled(mwah));
4.446 + RETURN_META_VALUE(MRES_OVERRIDE, META_RESULT_STATUS >= MRES_OVERRIDE ? !META_RESULT_OVERRIDE_RET(bool) :
4.447 + !META_RESULT_ORIG_RET(bool));
4.448 +}
4.449 +
4.450 +bool TestBasic(std::string &error)
4.451 +{
4.452 + SourceHook::CSourceHookImpl g_SHImpl;
4.453 + g_SHPtr = &g_SHImpl;
4.454 + g_PLID = 1337;
4.455 +
4.456 + HandlersF1 f1_handlers;
4.457 + Test test;
4.458 + Test *pTest = &test;
4.459 +
4.460 + // 1) Get a call class and call the member through it and normally
4.461 + SourceHook::CallClass<Test> *cc = SH_GET_CALLCLASS(pTest);
4.462 + ADD_STATE(State_F1_CallClassGenerated);
4.463 +
4.464 + SH_CALL(cc, &Test::F1)();
4.465 + pTest->F1();
4.466 +
4.467 + CHECK_STATES((&g_States,
4.468 + new State_F1_CallClassGenerated,
4.469 + new State_F1_Called,
4.470 + new State_F1_Called,
4.471 + NULL), "Part 1");
4.472 +
4.473 + // 2) Request a call class again
4.474 + SourceHook::CallClass<Test> *cc2 = SH_GET_CALLCLASS(pTest);
4.475 + ADD_STATE(State_F1_CallClassGenerated);
4.476 +
4.477 + SH_CALL(cc, &Test::F1)();
4.478 + SH_CALL(cc2, &Test::F1)();
4.479 + pTest->F1();
4.480 +
4.481 + SH_RELEASE_CALLCLASS(cc2);
4.482 + ADD_STATE(State_F1_CallClassReleased);
4.483 +
4.484 + SH_CALL(cc, &Test::F1)();
4.485 + pTest->F1();
4.486 +
4.487 + CHECK_STATES((&g_States,
4.488 + new State_F1_CallClassGenerated,
4.489 + new State_F1_Called,
4.490 + new State_F1_Called,
4.491 + new State_F1_Called,
4.492 + new State_F1_CallClassReleased,
4.493 + new State_F1_Called,
4.494 + new State_F1_Called,
4.495 + NULL), "Part 2");
4.496 +
4.497 + // 3) Add a pre hook
4.498 + g_F1Pre_WhatToDo = MRES_SUPERCEDE;
4.499 + ADD_STATE(State_F1_HookAdded(SH_ADD_HOOK_MEMFUNC(Test, F1, pTest, &f1_handlers, &HandlersF1::Pre, false)));
4.500 +
4.501 + SH_CALL(cc, &Test::F1)();
4.502 + pTest->F1();
4.503 +
4.504 + CHECK_STATES((&g_States,
4.505 + new State_F1_HookAdded(true),
4.506 + new State_F1_Called,
4.507 + new State_F1_PreHandler_Called,
4.508 + NULL), "Part 3");
4.509 +
4.510 + // 4) Rerequest the callclass
4.511 + SH_RELEASE_CALLCLASS(cc);
4.512 + ADD_STATE(State_F1_CallClassReleased);
4.513 + cc2 = SH_GET_CALLCLASS(pTest);
4.514 + ADD_STATE(State_F1_CallClassGenerated);
4.515 +
4.516 + SH_CALL(cc, &Test::F1)();
4.517 + pTest->F1();
4.518 +
4.519 + CHECK_STATES((&g_States,
4.520 + new State_F1_CallClassReleased,
4.521 + new State_F1_CallClassGenerated,
4.522 + new State_F1_Called,
4.523 + new State_F1_PreHandler_Called,
4.524 + NULL), "Part 4");
4.525 +
4.526 + // 5) Check ignore / supercede
4.527 + g_F1Pre_WhatToDo = MRES_SUPERCEDE;
4.528 + SH_CALL(cc, &Test::F1)();
4.529 + pTest->F1();
4.530 +
4.531 + g_F1Pre_WhatToDo = MRES_IGNORED;
4.532 + SH_CALL(cc, &Test::F1)();
4.533 + pTest->F1();
4.534 +
4.535 + CHECK_STATES((&g_States,
4.536 + new State_F1_Called,
4.537 + new State_F1_PreHandler_Called,
4.538 + new State_F1_Called,
4.539 + new State_F1_PreHandler_Called,
4.540 + new State_F1_Called,
4.541 + NULL), "Part 5");
4.542 +
4.543 + // 6) remove the hook again
4.544 + SH_REMOVE_HOOK_MEMFUNC(Test, F1, pTest, &f1_handlers, &HandlersF1::Pre, false);
4.545 + ADD_STATE(State_F1_HookRemoved);
4.546 +
4.547 + SH_CALL(cc, &Test::F1)();
4.548 + pTest->F1();
4.549 +
4.550 + CHECK_STATES((&g_States,
4.551 + new State_F1_HookRemoved,
4.552 + new State_F1_Called,
4.553 + new State_F1_Called,
4.554 + NULL), "Part 6");
4.555 +
4.556 + // 7) add a post hook now
4.557 + g_F1Post_WhatToDo = MRES_IGNORED;
4.558 + ADD_STATE(State_F1_HookAdded(SH_ADD_HOOK_MEMFUNC(Test, F1, pTest, &f1_handlers, &HandlersF1::Post, true)));
4.559 +
4.560 + SH_CALL(cc, &Test::F1)();
4.561 + pTest->F1();
4.562 +
4.563 + CHECK_STATES((&g_States,
4.564 + new State_F1_HookAdded(true),
4.565 + new State_F1_Called,
4.566 + new State_F1_Called,
4.567 + new State_F1_PostHandler_Called,
4.568 + NULL), "Part 7");
4.569 +
4.570 + // 8) And a pre hook again
4.571 + g_F1Pre_WhatToDo = MRES_IGNORED;
4.572 + ADD_STATE(State_F1_HookAdded(SH_ADD_HOOK_MEMFUNC(Test, F1, pTest, &f1_handlers, &HandlersF1::Pre, false)));
4.573 +
4.574 + SH_CALL(cc, &Test::F1)();
4.575 + pTest->F1();
4.576 +
4.577 + g_F1Pre_WhatToDo = MRES_SUPERCEDE;
4.578 + SH_CALL(cc, &Test::F1)();
4.579 + pTest->F1();
4.580 +
4.581 + CHECK_STATES((&g_States,
4.582 + new State_F1_HookAdded(true),
4.583 + new State_F1_Called,
4.584 + new State_F1_PreHandler_Called,
4.585 + new State_F1_Called,
4.586 + new State_F1_PostHandler_Called,
4.587 + new State_F1_Called,
4.588 + new State_F1_PreHandler_Called,
4.589 + new State_F1_PostHandler_Called,
4.590 + NULL), "Part 8");
4.591 +
4.592 + // 9) Remove all hooks
4.593 + SH_REMOVE_HOOK_MEMFUNC(Test, F1, pTest, &f1_handlers, &HandlersF1::Pre, false);
4.594 + ADD_STATE(State_F1_HookRemoved);
4.595 + SH_REMOVE_HOOK_MEMFUNC(Test, F1, pTest, &f1_handlers, &HandlersF1::Post, true);
4.596 + ADD_STATE(State_F1_HookRemoved);
4.597 +
4.598 + SH_CALL(cc, &Test::F1)();
4.599 + pTest->F1();
4.600 +
4.601 + CHECK_STATES((&g_States,
4.602 + new State_F1_HookRemoved,
4.603 + new State_F1_HookRemoved,
4.604 + new State_F1_Called,
4.605 + new State_F1_Called,
4.606 + NULL), "Part 9");
4.607 +
4.608 + // 10) Some checks on F299
4.609 + g_F299Pre_WhatToDo = MRES_IGNORED;
4.610 + g_F299Pre_WhatToRet = false;
4.611 +
4.612 + ADD_STATE(State_F299Ret(pTest->F299("hi")));
4.613 + ADD_STATE(State_F299Ret(SH_CALL(cc, &Test::F299)("hi")));
4.614 +
4.615 + CHECK_STATES((&g_States,
4.616 + new State_F299_Called("hi"),
4.617 + new State_F299Ret(true),
4.618 + new State_F299_Called("hi"),
4.619 + new State_F299Ret(true),
4.620 + NULL), "Part 10.1");
4.621 +
4.622 + SH_ADD_HOOK_STATICFUNC(Test, F299, pTest, F299_Pre, false);
4.623 + ADD_STATE(State_F299Ret(pTest->F299("hi")));
4.624 + ADD_STATE(State_F299Ret(SH_CALL(cc, &Test::F299)("hi")));
4.625 +
4.626 + CHECK_STATES((&g_States,
4.627 + new State_F299_PreHandlerCalled("hi"),
4.628 + new State_F299_Called("hi"),
4.629 + new State_F299Ret(true),
4.630 + new State_F299_Called("hi"),
4.631 + new State_F299Ret(true),
4.632 + NULL), "Part 10.2");
4.633 +
4.634 + SH_ADD_HOOK_STATICFUNC(Test, F299, pTest, F299_Post, true);
4.635 + ADD_STATE(State_F299Ret(pTest->F299("hi")));
4.636 + ADD_STATE(State_F299Ret(SH_CALL(cc, &Test::F299)("hi")));
4.637 +
4.638 + CHECK_STATES((&g_States,
4.639 + new State_F299_PreHandlerCalled("hi"),
4.640 + new State_F299_Called("hi"),
4.641 + new State_F299_PostHandlerCalled("hi"),
4.642 + new State_F299Ret(false),
4.643 + new State_F299_Called("hi"),
4.644 + new State_F299Ret(true),
4.645 + NULL), "Part 10.3");
4.646 +
4.647 + g_F299Pre_WhatToDo = MRES_OVERRIDE;
4.648 + ADD_STATE(State_F299Ret(pTest->F299("hi")));
4.649 + ADD_STATE(State_F299Ret(SH_CALL(cc, &Test::F299)("hi")));
4.650 +
4.651 + CHECK_STATES((&g_States,
4.652 + new State_F299_PreHandlerCalled("hi"),
4.653 + new State_F299_Called("hi"),
4.654 + new State_F299_PostHandlerCalled("hi"),
4.655 + new State_F299Ret(true),
4.656 + new State_F299_Called("hi"),
4.657 + new State_F299Ret(true),
4.658 + NULL), "Part 10.4");
4.659 +
4.660 + g_F299Pre_WhatToDo = MRES_SUPERCEDE;
4.661 + ADD_STATE(State_F299Ret(pTest->F299("hi")));
4.662 + ADD_STATE(State_F299Ret(SH_CALL(cc, &Test::F299)("hi")));
4.663 +
4.664 + CHECK_STATES((&g_States,
4.665 + new State_F299_PreHandlerCalled("hi"),
4.666 + new State_F299_PostHandlerCalled("hi"),
4.667 + new State_F299Ret(true),
4.668 + new State_F299_Called("hi"),
4.669 + new State_F299Ret(true),
4.670 + NULL), "Part 10.5");
4.671 +
4.672 + SH_REMOVE_HOOK_STATICFUNC(Test, F299, pTest, F299_Pre, false);
4.673 + ADD_STATE(State_F299Ret(pTest->F299("hi")));
4.674 + ADD_STATE(State_F299Ret(SH_CALL(cc, &Test::F299)("hi")));
4.675 +
4.676 + CHECK_STATES((&g_States,
4.677 + new State_F299_Called("hi"),
4.678 + new State_F299_PostHandlerCalled("hi"),
4.679 + new State_F299Ret(false),
4.680 + new State_F299_Called("hi"),
4.681 + new State_F299Ret(true),
4.682 + NULL), "Part 10.6");
4.683 +
4.684 + SH_REMOVE_HOOK_STATICFUNC(Test, F299, pTest, F299_Post, true);
4.685 + ADD_STATE(State_F299Ret(pTest->F299("hi")));
4.686 + ADD_STATE(State_F299Ret(SH_CALL(cc, &Test::F299)("hi")));
4.687 +
4.688 + CHECK_STATES((&g_States,
4.689 + new State_F299_Called("hi"),
4.690 + new State_F299Ret(true),
4.691 + new State_F299_Called("hi"),
4.692 + new State_F299Ret(true),
4.693 + NULL), "Part 10.7");
4.694 +
4.695 + // 11) Release callclass
4.696 + SH_RELEASE_CALLCLASS(cc);
4.697 + ADD_STATE(State_F1_CallClassReleased);
4.698 +
4.699 +
4.700 + CHECK_STATES((&g_States,
4.701 + new State_F1_CallClassReleased,
4.702 + NULL), "Part 11");
4.703 +
4.704 + return true;
4.705 +}
4.706 \ No newline at end of file