Some fixes, new test system
authorPavol Marko <pavolmarko@gmail.com>
Sat Apr 30 15:48:46 2005 +0000 (2005-04-30)
changeset 42390a2aec00e4
parent 41 534eac4c53ef
child 43 3d58806eb2e3
Some fixes, new test system
sourcehook/sourcehook.cpp
sourcehook/sourcehook_impl.h
sourcehook/test/main.cpp
sourcehook/test/test1.cpp
     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