core/sourcehook/test/testevents.h
author Scott Ehlert <ds@alliedmods.net>
Thu Dec 10 00:59:50 2009 -0600 (2009-12-10)
changeset 689 4065ba5e9155
parent 539 db914129ae01
permissions -rw-r--r--
Rewrote user message caching code to always use IServerGameDLL::GetUserMessageInfo (bug 4117, r=dvander).

Games where the above function can crash are handled by detouring tier0's Error() function and jumping back to our own code. So in theory this should work on all games now.
     1 /* ======== SourceHook ========
     2 * Copyright (C) 2004-2008 Metamod:Source Development Team
     3 * No warranties of any kind
     4 *
     5 * License: zlib/libpng
     6 *
     7 * Author(s): Pavol "PM OnoTo" Marko
     8 * ============================
     9 */
    10 
    11 #ifndef __TESTEVENTS_H__
    12 #define __TESTEVENTS_H__
    13 
    14 #include <typeinfo>
    15 #include <stdarg.h>
    16 #include <iostream>
    17 #include <list>
    18 #include <string>
    19 
    20 extern bool g_Verbose;
    21 
    22 static unsigned int MakeHash(const char *name)
    23 {
    24 	int a = 0;
    25 	unsigned int res = 0xFFFFFFFF;
    26 
    27 	while (*name)
    28 	{
    29 		res ^= ((unsigned int)*name << ((a++ % 4)*8));
    30 		++name;
    31 	}
    32 	return res;
    33 }
    34 
    35 struct State
    36 {
    37 	virtual ~State()
    38 	{
    39 
    40 	}
    41 
    42 	virtual bool IsEqual(State *other)
    43 	{
    44 		return (MakeHash(GetName()) == MakeHash(other->GetName())) ? true : false;
    45 	}
    46 
    47 	virtual bool Ignore()
    48 	{
    49 		return false;
    50 	}
    51 
    52 	virtual void Dump() = 0;
    53 	virtual const char *GetName() = 0;
    54 };
    55 
    56 struct IgnoreState : public State
    57 {
    58 	virtual bool Ignore()
    59 	{
    60 		return true;
    61 	}
    62 	virtual void Dump()
    63 	{
    64 	}
    65 };
    66 
    67 typedef std::list<State*> StateList;
    68 namespace
    69 {
    70 	void DumpStates(StateList *sl)
    71 	{
    72 		for (StateList::iterator iter = sl->begin(); iter != sl->end(); ++iter)
    73 			(*iter)->Dump();
    74 	}
    75 
    76 	bool StatesOk(StateList *sl, ...)
    77 	{
    78 		StateList requiredstates;
    79 		va_list argptr;
    80 		va_start(argptr, sl);
    81 		while (true)
    82 		{
    83 			State *cs = va_arg(argptr, State*);
    84 			if (!cs)
    85 				break;
    86 			if (cs->Ignore())
    87 				continue;
    88 			requiredstates.push_back(cs);
    89 		}
    90 		va_end(argptr);
    91 
    92 		if (requiredstates.size() != sl->size())
    93 		{
    94 			if (g_Verbose)
    95 			{
    96 				std::cout << std::endl << "FAIL: Should be:" << std::endl;
    97 				DumpStates(&requiredstates);
    98 				std::cout << std::endl << "FAIL: Is:" << std::endl;
    99 				DumpStates(sl);
   100 			}
   101 
   102 			for (StateList::iterator iter = requiredstates.begin(); iter != requiredstates.end(); ++iter)
   103 				delete *iter;
   104 			for (StateList::iterator iter = sl->begin(); iter != sl->end(); ++iter)
   105 				delete *iter;
   106 			sl->clear();
   107 			return false;
   108 		}
   109 
   110 		bool ok = true;
   111 		StateList::iterator req_iter = requiredstates.begin();
   112 		for (StateList::iterator o_iter = sl->begin(); o_iter != sl->end(); ++o_iter, ++req_iter)
   113 		{
   114 			if (!(*o_iter)->IsEqual(*req_iter))
   115 			{
   116 				ok = false;
   117 				break;
   118 			}
   119 		}
   120 
   121 		if (!ok && g_Verbose)
   122 		{
   123 			std::cout << std::endl << "FAIL: Should be:" << std::endl;
   124 			DumpStates(&requiredstates);
   125 			std::cout << std::endl << "FAIL: Is:" << std::endl;
   126 			DumpStates(sl);
   127 		}
   128 
   129 		for (StateList::iterator iter = requiredstates.begin(); iter != requiredstates.end(); ++iter)
   130 			delete *iter;
   131 		for (StateList::iterator iter = sl->begin(); iter != sl->end(); ++iter)
   132 			delete *iter;
   133 		sl->clear();
   134 
   135 		return ok;
   136 	}
   137 }
   138 
   139 #define ADD_STATE(name) g_States.push_back(new name)
   140 #define ADD_STATE_PTR(statesptr, name) statesptr->push_back(new name)
   141 
   142 #define CHECK_STATES(mwah, myerr) if (!StatesOk mwah) { error=myerr; return false; } else if (g_Verbose) { std::cout << "No error: " << myerr << std::endl; }
   143 
   144 #define MAKE_STATE(name) struct name : State { \
   145 		virtual void Dump() { \
   146 			std::cout << "  " << #name << std::endl; } \
   147 		const char *GetName() { return #name; } \
   148 	};
   149 
   150 #define MAKE_STATE_1(name, p1_type) struct name : State { \
   151 		p1_type m_Param1; \
   152 		name(p1_type param1) : m_Param1(param1) {} \
   153 		virtual bool IsEqual(State *other) { \
   154 			if (MakeHash(GetName()) != MakeHash(other->GetName())) \
   155 				return false; \
   156 			name *other2 = static_cast<name*>(other); \
   157 			return other2->m_Param1 == m_Param1;\
   158 		} \
   159 		virtual void Dump() { \
   160 			std::cout << "  " << #name << "; Param1=" << m_Param1 << std::endl; } \
   161 		const char *GetName() { return #name; } \
   162 	}
   163 
   164 #define MAKE_STATE_2(name, p1_type, p2_type) struct name : State { \
   165 		p1_type m_Param1; \
   166 		p2_type m_Param2; \
   167 		name(p1_type param1, p2_type param2) : m_Param1(param1), m_Param2(param2) {} \
   168 		virtual bool IsEqual(State *other) { \
   169 			if (MakeHash(GetName()) != MakeHash(other->GetName())) \
   170 				return false; \
   171 			name *other2 = static_cast<name*>(other); \
   172 			return other2->m_Param1 == m_Param1 && other2->m_Param2 == m_Param2;\
   173 		} \
   174 		virtual void Dump() { \
   175 			std::cout << "  " << #name << "; Param1=" << m_Param1 << "; Param2=" << m_Param2 << std::endl; } \
   176 		const char *GetName() { return #name; } \
   177 	}
   178 
   179 #define MAKE_STATE_3(name, p1_type, p2_type, p3_type) struct name : State { \
   180 		p1_type m_Param1; \
   181 		p2_type m_Param2; \
   182 		p3_type m_Param3; \
   183 		name(p1_type param1, p2_type param2, p3_type param3) : m_Param1(param1), m_Param2(param2), m_Param3(param3) {} \
   184 		virtual bool IsEqual(State *other) { \
   185 			if (MakeHash(GetName()) != MakeHash(other->GetName())) \
   186 				return false; \
   187 			name *other2 = static_cast<name*>(other); \
   188 			return other2->m_Param1 == m_Param1 && other2->m_Param2 == m_Param2 && other2->m_Param3 == m_Param3;\
   189 		} \
   190 		virtual void Dump() { \
   191 			std::cout << "  " << #name << "; Param1=" << m_Param1 << "; Param2=" << m_Param2 << "; Param3=" << m_Param3 << std::endl; } \
   192 		const char *GetName() { return #name; } \
   193 	}
   194 
   195 #define MAKE_STATE_4(name, p1_type, p2_type, p3_type, p4_type) struct name : State { \
   196 		p1_type m_Param1; \
   197 		p2_type m_Param2; \
   198 		p3_type m_Param3; \
   199 		p4_type m_Param4; \
   200 		name(p1_type param1, p2_type param2, p3_type param3, p4_type param4) : m_Param1(param1), m_Param2(param2), m_Param3(param3), m_Param4(param4) {} \
   201 		virtual bool IsEqual(State *other) { \
   202 			if (MakeHash(GetName()) != MakeHash(other->GetName())) \
   203 				return false; \
   204 			name *other2 = static_cast<name*>(other); \
   205 			return other2->m_Param1 == m_Param1 && other2->m_Param2 == m_Param2 && other2->m_Param3 == m_Param3 && other2->m_Param4 == m_Param4;\
   206 		} \
   207 		virtual void Dump() { \
   208 			std::cout << "  " << #name << "; Param1=" << m_Param1 << "; Param2=" << m_Param2 << "; Param3=" << m_Param3 << "; Param4=" << m_Param4 << std::endl; } \
   209 		const char *GetName() { return #name; } \
   210 	}
   211 
   212 #define CHECK_COND(c, err) if (!(c)) { error = err; return false; }
   213 
   214 #endif