sourcehook/test/testevents.h
author Scott Ehlert <ds@alliedmods.net>
Mon Nov 10 16:57:53 2008 -0600 (2008-11-10)
changeset 537 2ebaf6a4f86f
parent 523 6f1630519b81
permissions -rw-r--r--
Added SOURCE_ENGINE_LEFT4DEAD constant for future use
     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