changed repo to lgsm-cs-funmaps

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/admins_test.sma

@@ -0,0 +1,123 @@
+#include <amxmodx>
+
+new __testnumber;
+new errcount;
+
+enum TestType
+{
+	TT_Equal = 0,
+	TT_LessThan,
+	TT_GreaterThan,
+	TT_LessThanEqual,
+	TT_GreaterThanEqual,
+	TT_NotEqual
+};
+
+new TestWords[6][] = {
+ "==",
+ "<",
+ ">",
+ "<=",
+ ">=",
+ "!="
+};
+
+
+
+stock test(A,B=0,TestType:Type=TT_Equal)
+{
+	++__testnumber;
+	
+	new passed=0;
+	
+	switch (Type)
+	{
+		case TT_Equal: if (A==B) passed=1;
+		case TT_LessThan: if (A<B) passed=1;
+		case TT_GreaterThan: if (A>B) passed=1;
+		case TT_LessThanEqual: if (A<=B) passed=1;
+		case TT_GreaterThanEqual: if (A>=B) passed=1;
+		case TT_NotEqual: if (A!=B) passed=1;
+	}
+	
+	if (!passed)
+	{
+		log_amx("Failed test #%d (%d %s %d)",__testnumber,A,TestWords[_:Type],B);
+		errcount++;
+	}
+}
+
+
+public plugin_init()
+{
+	register_srvcmd("testadmins","testadmins");
+}
+public testadmins()
+{
+
+	new AuthData[44];
+	new Password[32];
+	new Access;
+	new Flags;
+	new id;
+	
+	__testnumber=0;
+	errcount=0;
+	
+
+	test(admins_num(),0);
+	
+	admins_push("STEAM_0:1:23456","",read_flags("abcdefghijklmnopqrstu"),read_flags("ce"));
+	
+	test(admins_num(),1);
+	
+	admins_push("ABCDEFGHIJKLMNOP","abcdefghijklmnop",read_flags("z"),read_flags("a"));
+	
+	test(admins_num(),2);
+	
+	admins_push("ZYXWVUTSRQPONMLKJIHGFEDCBA","plop",read_flags("a"),read_flags("b"));
+	
+	test(admins_num(),3);
+	
+	id=0;
+	
+	admins_lookup(id,AdminProp_Auth,AuthData,sizeof(AuthData)-1); 
+	admins_lookup(id,AdminProp_Password,Password,sizeof(Password)-1); 
+	Access=admins_lookup(id,AdminProp_Access); 
+	Flags=admins_lookup(id,AdminProp_Flags);
+	
+	test(strcmp(AuthData,"STEAM_0:1:23456"),0);
+	test(strcmp(Password,""),0);
+	test(Access,read_flags("abcdefghijklmnopqrstu"));
+	test(Flags,read_flags("ce"));
+	
+	id++;
+	
+	admins_lookup(id,AdminProp_Auth,AuthData,sizeof(AuthData)-1); 
+	admins_lookup(id,AdminProp_Password,Password,sizeof(Password)-1); 
+	Access=admins_lookup(id,AdminProp_Access); 
+	Flags=admins_lookup(id,AdminProp_Flags);
+
+	test(strcmp(AuthData,"ABCDEFGHIJKLMNOP"),0);
+	test(strcmp(Password,"abcdefghijklmnop"),0);
+	test(Access,read_flags("z"));
+	test(Flags,read_flags("a"));
+	
+	id++;
+	
+	admins_lookup(id,AdminProp_Auth,AuthData,sizeof(AuthData)-1); 
+	admins_lookup(id,AdminProp_Password,Password,sizeof(Password)-1); 
+	Access=admins_lookup(id,AdminProp_Access); 
+	Flags=admins_lookup(id,AdminProp_Flags);
+	
+	test(strcmp(AuthData,"ZYXWVUTSRQPONMLKJIHGFEDCBA"),0);
+	test(strcmp(Password,"plop"),0);
+	test(Access,read_flags("a"));
+	test(Flags,read_flags("b"));
+	
+	admins_flush();
+	
+	test(admins_num(),0);
+	
+	server_print("test complete, %d errors",errcount);
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/arraytest.sma

@@ -0,0 +1,459 @@
+#include <amxmodx>
+
+
+new __testnumber;
+new errcount;
+new __testfunc[32];
+new __testfuncnum;
+
+enum TestType
+{
+	TT_Equal = 0,
+	TT_LessThan,
+	TT_GreaterThan,
+	TT_LessThanEqual,
+	TT_GreaterThanEqual,
+	TT_NotEqual
+};
+
+new TestWords[6][] = {
+ "==",
+ "<",
+ ">",
+ "<=",
+ ">=",
+ "!="
+};
+
+
+
+stock test(A,B=0,TestType:Type=TT_Equal)
+{
+	++__testnumber;
+	
+	new passed=0;
+	
+	switch (Type)
+	{
+		case TT_Equal: if (A==B) passed=1;
+		case TT_LessThan: if (A<B) passed=1;
+		case TT_GreaterThan: if (A>B) passed=1;
+		case TT_LessThanEqual: if (A<=B) passed=1;
+		case TT_GreaterThanEqual: if (A>=B) passed=1;
+		case TT_NotEqual: if (A!=B) passed=1;
+	}
+	
+	if (!passed)
+	{
+		log_amx("Failed test #%d (%d %s %d)",__testnumber,A,TestWords[_:Type],B);
+		errcount++;
+	}
+}
+stock starttests(const startfunc[])
+{
+	__testnumber=0;
+	errcount=0;
+	__testfuncnum=1;
+	server_print("Starting tests...");
+	formatex(__testfunc,sizeof(__testfunc)-1,"%s",startfunc);
+
+	new func[32];
+	formatex(func,sizeof(func)-1,"%s%d",__testfunc,__testfuncnum++);
+	set_task(0.1,func);
+}
+
+stock showres()
+{
+	if (errcount==0)
+	{
+		new func[32];
+		formatex(func,sizeof(func)-1,"%s%d",__testfunc,__testfuncnum++);
+		if (get_func_id(func)==-1)
+		{
+			server_print("All tests ok!");
+		}
+		else
+		{
+			server_print("Test ok, moving on...");
+			
+			set_task(0.1,func);
+		}
+	}
+	else
+	{
+		server_print("Test failed, aborting.");
+	}
+}
+
+
+
+public plugin_init()
+{
+	register_srvcmd("arraytest","arraytest");
+}
+
+public arraytest()
+{
+	starttests("arraytest");
+}
+public arraytest1()
+{
+	server_print("Testing 1000 iterations of 1-cell arrays...");
+	
+	new Float:f;
+	new Array:a=ArrayCreate(1);
+	if (a == Invalid_Array)
+	{
+	}
+	for (new i=0; i<1000; i++)
+	{
+		f=float(i);
+		ArrayPushCell(a,f);
+	}
+	new Float:r;
+	for (new i=0; i<1000; i++)
+	{
+		f=float(i);
+		r=Float:ArrayGetCell(a, i);
+		
+		// This is normally bad for float "casting", but in this case it should be fine.
+		test(_:f, _:r);
+		
+		
+		// Reset with inversed values
+		new g=_:f;
+		g=~g;
+		
+		ArraySetCell(a, i, g);
+		
+		r=Float:ArrayGetCell(a,i);
+		
+		test(g, _:r);
+		
+	}
+	
+	ArrayDestroy(a);
+	
+	showres();
+}
+stock bool:checkarray(const a[], const b[], size)
+{
+	while (size--)
+	{
+		if (a[size]!=b[size])
+		{
+			return false;
+		}
+	}
+	
+	return true;
+}
+stock invarray(a[],size)
+{
+	while (size--)
+	{
+		a[size] = ~a[size];
+	}
+	
+}
+public arraytest2()
+{
+	server_print("Testing 1000 iterations of 40-cell arrays...");
+	
+	new Array:a=ArrayCreate(40);
+	new buff[40];
+	new buffb[40];
+	for (new i=0; i<1000; i++)
+	{
+		arrayset(buff,i,sizeof(buff));
+		
+		ArrayPushArray(a, buff);
+	}
+	for (new i=0; i<1000; i++)
+	{
+		arrayset(buff, i, sizeof(buff));
+		
+		ArrayGetArray(a, i, buffb);
+		
+		test(_:checkarray(buff,buffb,sizeof(buff)),1);
+		
+		// Now overwrite the array with inversed value
+		invarray(buff,sizeof(buff));
+		
+		ArraySetArray(a, i, buff);
+		
+		ArrayGetArray(a, i, buffb);
+		
+		test(_:checkarray(buff,buffb,sizeof(buff)),1);
+	}
+	
+	ArrayDestroy(a);
+	
+	showres();
+}
+public arraytest3()
+{
+	server_print("Testing 1000 iterations of strings...");
+	
+	// The string is 10 long, the string we're trying to pass is 20 long.
+	
+	new Array:a=ArrayCreate(10);
+	
+	new buff[20]="1234567890abcdefghi";
+	new buffb[20];
+	
+	for (new i=0; i<1000; i++)
+	{
+		ArrayPushString(a, buff);
+	}
+	for (new i=0; i<1000; i++)
+	{
+		ArrayGetString(a, i, buffb, sizeof(buffb)-1);
+		
+		test(strcmp(buffb,"123456789"),0);
+		
+		ArraySetString(a, i, "9876543210");
+		
+		ArrayGetString(a, i, buffb, sizeof(buffb)-1);
+		
+		test(strcmp(buffb,"987654321"),0);
+		
+		buffb[0]=0;
+		
+		formatex(buffb,sizeof(buffb)-1,"%S", ArrayGetStringHandle(a, i));
+		
+		test(strcmp(buffb, "987654321"),0);
+	}
+	
+	ArrayDestroy(a);
+	
+	showres();
+}
+
+public sortcallback(Array:a, b, c)
+{
+	static stra[40];
+	static strb[40];
+	
+	ArrayGetString(a, b, stra, sizeof(stra)-1);
+	ArrayGetString(a, c, strb, sizeof(strb)-1);
+	return strcmp(stra,strb);
+}
+public arraytest4()
+{
+	server_print("Testing sorting function...");
+	
+	new Array:a=ArrayCreate(40);
+	
+	ArrayPushString(a, "z");
+	ArrayPushString(a, "yz");
+	ArrayPushString(a, "xyz");
+	ArrayPushString(a, "wxyz");
+	ArrayPushString(a, "vwxyz");
+	ArrayPushString(a, "uvwxyz");
+	ArrayPushString(a, "tuvwxyz");
+	ArrayPushString(a, "stuvwxyz");
+	ArrayPushString(a, "rstuvwxyz");
+	ArrayPushString(a, "qrstuvwxyz");
+	ArrayPushString(a, "pqrstuvwxyz");
+	ArrayPushString(a, "opqrstuvwxyz");
+	ArrayPushString(a, "nopqrstuvwxyz");
+	ArrayPushString(a, "mnopqrstuvwxyz");
+	ArrayPushString(a, "lmnopqrstuvwxyz");
+	ArrayPushString(a, "klmnopqrstuvwxyz");
+	ArrayPushString(a, "jklmnopqrstuvwxyz");
+	ArrayPushString(a, "ijklmnopqrstuvwxyz");
+	ArrayPushString(a, "hijklmnopqrstuvwxyz");
+	ArrayPushString(a, "ghijklmnopqrstuvwxyz");
+	ArrayPushString(a, "fghijklmnopqrstuvwxyz");
+	ArrayPushString(a, "efghijklmnopqrstuvwxyz");
+	ArrayPushString(a, "defghijklmnopqrstuvwxyz");
+	ArrayPushString(a, "cdefghijklmnopqrstuvwxyz");
+	ArrayPushString(a, "bcdefghijklmnopqrstuvwxyz");
+	ArrayPushString(a, "abcdefghijklmnopqrstuvwxyz");
+	
+	new OldSize=ArraySize(a);
+	
+	ArraySort(a, "sortcallback");
+	
+	test(ArraySize(a),OldSize);
+	
+	new buff[40];
+	
+	ArrayGetString(a,0,buff,sizeof(buff)-1);
+
+	test(strcmp(buff,"abcdefghijklmnopqrstuvwxyz"),0);
+	
+	ArrayGetString(a,25,buff,sizeof(buff)-1);
+	
+	test(strcmp(buff,"z"),0);
+
+	
+	new start='a';
+	
+	for (new i=0;i<OldSize;i++)
+	{
+		ArrayGetString(a,i,buff,sizeof(buff)-1)
+		
+		test(buff[0],start++);
+	}
+	
+	showres();
+}
+public arraytest5()
+{
+	server_print("Testing ArrayDeleteItem()...");
+	new Array:a=ArrayCreate(1);
+	
+	new v;
+	
+	for (new i=0; i<1000; i++)
+	{
+		ArrayPushCell(a, i);
+	}
+	for (new i=ArraySize(a) - 1; i>=0 ; i--)
+	{
+		if (i % 2 == 0)
+		{
+			ArrayDeleteItem(a, i);
+		}
+	}
+	test(ArraySize(a), 500);
+	for (new i=0; i< 500; i++)
+	{
+		v=ArrayGetCell(a, i);
+		
+		// All items should be incrementing odd numbers
+		test(((i + 1) * 2) - 1, v);
+
+		// All remaining entries should be odd
+		test((v & 1), 1);
+	}
+	ArrayDestroy(a);
+	
+	a=ArrayCreate(1);
+	// Repeat the same test, but check even numbers
+	for (new i=0; i<1000; i++)
+	{
+		ArrayPushCell(a, i);
+	}
+	for (new i=ArraySize(a) - 1; i>=0 ; i--)
+	{
+		if (i % 2 == 1)
+		{
+			ArrayDeleteItem(a, i);
+		}
+	}
+	test(ArraySize(a), 500);
+	for (new i=0; i< 500; i++)
+	{
+		v=ArrayGetCell(a, i);
+		
+		// All items should be incrementing even numbers
+		test(((i + 1) * 2) - 2, v);
+
+		// All remaining entries should be even
+		test((v & 1), 0);
+	}
+	ArrayDestroy(a);
+	
+	showres();
+}
+public arraytest6()
+{
+	server_print("Testing ArrayInsertCellAfter()...");
+	
+	new Array:a=ArrayCreate(1);
+	
+	for (new i=0; i<10;i++)
+	{
+		ArrayPushCell(a, i);
+		new item=ArraySize(a)-1;
+		for (new j=0; j<10; j++)
+		{
+			ArrayInsertCellAfter(a, item + j, j);
+		}
+	}
+	
+	test(ArraySize(a), 110);
+	
+	new v;
+	for (new i=0; i<110; i++)
+	{
+		v=ArrayGetCell(a, i);
+		
+		test(v, i / 10);
+		for (new j=0; j<10; j++)
+		{
+			v=ArrayGetCell(a, ++i);
+			test(v, j);
+		}
+	}
+	
+	
+	ArrayDestroy(a);
+	
+	showres();
+}
+public arraytest7()
+{
+	server_print("Testing ArrayInsertCellBefore()...");
+	
+	new Array:a=ArrayCreate(1);
+	
+	for (new i=0; i<10;i++)
+	{
+		ArrayPushCell(a, i);
+		new item=ArraySize(a)-1;
+		for (new j=0; j<10; j++)
+		{
+			ArrayInsertCellBefore(a, item, j);
+		}
+	}
+	
+	test(ArraySize(a), 110);
+	
+	new v;
+	for (new i=0; i<110; i++)
+	{
+		for (new j=9; j>=0; j--)
+		{
+			v=ArrayGetCell(a, i++);
+			test(v, j);
+		}
+		
+		v=ArrayGetCell(a, i);
+		
+		test(v, (i - 10) / 10);
+	}
+	
+	
+	ArrayDestroy(a);
+	
+	showres();
+}
+public arraytest8()
+{
+	server_print("Testing ArraySwap()...");
+	new Array:a=ArrayCreate(1);
+	
+	for (new i=0; i<10; i++)
+	{
+		ArrayPushCell(a, i);
+	}
+	for (new i=0; i<5; i++)
+	{
+		ArraySwap(a, i, (10 - (i + 1)));
+	}
+	new v;
+	for (new i=0; i<5; i++)
+	{
+		v=ArrayGetCell(a, i);
+		
+		test(v, (10 - (i + 1)));
+	}
+	
+	ArrayDestroy(a);
+	
+	showres();
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/callfunc_test.sma

@@ -0,0 +1,60 @@
+#include <amxmodx>
+
+public plugin_init()
+{
+	register_plugin("callfunc test", "1.0", "BAILOPAN")
+	
+	register_srvcmd("test_callfunc", "Command_Callfunc")
+}
+
+public OnCallfuncReceived(num, str[], &val, array[], array2[], size, hello2[1])
+{
+	server_print("num = %d (expected: %d)", num, 5)
+	server_print("str[] = ^"%s^" (expected: %s)", str, "Gaben")
+
+	server_print("val = %d (expected %d, setting to %d)", val, 62, 15)
+	val = 15
+	server_print("printing %d elements of array[] (expected: %d)", size, 6)
+	for (new i=0; i<size; i++)
+	{
+		server_print("array[%d] = %d (expected: %d)", i, array[i], i)
+	}
+	for (new i=0; i<size; i++)
+	{
+		server_print("array2[%d] = %d (expected: %d)", i, array[i], i)
+	}
+	array[0] = 5
+	array2[1] = 6
+	hello2[0] = 25
+}
+
+public Command_Callfunc()
+{
+	new a = 62
+	new hello[] = {0,1,2,3,4,5}
+	new hello2[] = {9}
+	new pm = 6
+	new err
+	
+	if ((err=callfunc_begin("OnCallfuncReceived")) < 1)
+	{
+		server_print("Failed to call callfunc_begin()! Error: %d", err)
+		
+		return PLUGIN_HANDLED
+	}
+	callfunc_push_int(5)
+	callfunc_push_str("Gaben")
+	callfunc_push_intrf(a)
+	callfunc_push_array(hello, pm)
+	callfunc_push_array(hello, pm)
+	callfunc_push_int(pm)
+	callfunc_push_array(hello2, 1, false)
+	callfunc_end()
+	
+	server_print("a = %d (expected: %d)", a, 15)
+	server_print("hello[0] = %d (expected: %d)", hello[0], 5)
+	server_print("hello[1] = %d (expected: %d)", hello[1], 6)
+	server_print("hello2[0] = %d (expected: %d)", hello2[0], 9)
+	
+	return PLUGIN_HANDLED
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/fakemeta_tests.sma

@@ -0,0 +1,18 @@
+#include <amxmodx>
+#include <fakemeta>
+
+public plugin_init()
+{
+	register_plugin("Fakemeta Tests", "1.0", "BAILOPAN")
+	register_forward(FM_ServerDeactivate, "Hook_ServerDeactivate")
+}
+
+public Hook_ServerDeactivate()
+{
+	server_print("[FAKEMETA TEST] ServerDeactivate() at %f", get_gametime())
+}
+
+public plugin_end()
+{
+	server_print("[FAKEMETA TEST] plugin_end() at %f", get_gametime())
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/fmttest.sma

@@ -0,0 +1,58 @@
+#include <amxmodx>
+
+public plugin_init()
+{
+	register_plugin("Format Test", "1.0", "BAILOPAN")
+	
+	register_srvcmd("test_format", "Command_TestFormat")
+	register_srvcmd("test_replace", "Command_TestReplace")
+}
+
+public gabprint(const fmt[], ...)
+{
+	static buffer[2048]
+	vformat(buffer, 2047, fmt, 2)
+	
+	server_print("%s", buffer)
+}
+
+public Command_TestFormat()
+{
+	server_print("Printing -1 with d: %d", -1)
+	server_print("Printing -1 with u: %u", -1)
+	server_print("Printing (1<<31) with d: %d", (1<<31))
+	server_print("Printing (1<<31) with u: %u", (1<<31))
+	server_print("Printing 1 with d: %d", 1)
+	server_print("Printing 1 with u: %u", 1)
+}
+
+public Command_TestReplace()
+{
+	new message[192] = "^"@test^""
+	
+	replace_all(message, 191, "^"", "")
+	server_print("Got: %s (expected: %s)", message, "@test")
+	
+	copy(message, 191, "test")
+	replace_all(message, 191, "t", "tt")
+	server_print("Got: %s (expected: %s)", message, "ttestt")
+	
+	replace_all(message, 191, "tt", "")
+	server_print("Got: %s (expected: %s)", message, "es")
+	
+	copy(message, 191, "good boys do fine always")
+	replace_all(message, 191, " ", "-----")
+	server_print("Got %s (expected: %s)", message, "good-----boys-----do-----fine-----always")
+	
+	copy(message, 191, "-----")
+	replace_all(message, 191, "-", "")
+	server_print("Got ^"%s%^" (expected: ^"%s%^")", message, "")
+	
+	copy(message, 191, "-----")
+	replace_all(message, 191, "--", "")
+	server_print("Got ^"%s%^" (expected: ^"%s%^")", message, "-")
+	
+	copy(message, 191, "aaaa")
+	replace_all(message, 191, "a", "Aaa")
+	server_print("Got %s (expected: %s)", message, "AaaAaaAaaAaa")
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/fwdtest1.sma

@@ -0,0 +1,54 @@
+#include <amxmodx>
+
+new g_forward
+new g_id
+
+public plugin_init()
+{
+	g_id = register_plugin("Foward Test (Master)", "1.0", "Belsebub")
+}
+
+public plugin_natives()
+{
+	register_native("test_createforward", "test_createforward_handler")
+	register_native("test_executeforward", "test_executeforward_handler")
+}
+
+//test_createforward(function[])
+public test_createforward_handler(pluginid, numparams)
+{
+	server_print("(test_createforward_handler: %d,%d)", pluginid, numparams)
+	
+	new function[32]
+	get_string(1, function, 31)
+	
+	if (g_forward > 0)
+	{
+		DestroyForward(g_forward)
+	}
+
+	g_forward = CreateOneForward(pluginid, function)
+	if (g_forward < 0)
+	{
+		server_print("Failed to create forward!")
+	}
+}
+
+//test_executeforward()
+public test_executeforward_handler(pluginid, numparams)
+{
+	new retval
+	
+	server_print("(test_executeforward_handler: %d,%d)", pluginid, numparams)
+
+	if (!ExecuteForward(g_forward, retval))
+	{
+		server_print("failed to execute forward (I'm %d)", g_id)
+	}
+	
+	if (g_forward > 0)
+	{
+		DestroyForward(g_forward)
+		g_forward = -1
+	}
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/fwdtest2.sma

@@ -0,0 +1,25 @@
+#include <amxmodx>
+
+new g_id
+
+native test_createforward(function[])
+native test_executeforward()
+
+public plugin_init()
+{
+	g_id = register_plugin("Forward Test (Client)", "1.0", "Belsebub")
+	
+	register_srvcmd("fwd_test1", "Test_Forward1")
+}
+
+public Test_Forward1()
+{
+	server_print("Executing forward ^"gaben^" (I'm %d)", g_id)
+	test_createforward("gaben")
+	test_executeforward()	
+}
+
+public gaben()
+{
+	server_print("gaben executed (I'm %d)", g_id)
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/logtest.sma

@@ -0,0 +1,45 @@
+#include <amxmodx>
+
+new g_BlockLog
+
+public plugin_init()
+{
+	register_plugin("Log Tester", "1.0", "BAILOPAN")
+	register_srvcmd("log_addlogevent", "Command_AddLogEvent")
+	register_srvcmd("log_setblock", "Command_LogSetBlock")
+}
+
+public event_round_start()
+{
+
+}
+
+public Command_LogSetBlock()
+{
+	if (read_argc() < 2)
+	{
+		server_print("Specify 1 or 0.")
+		return PLUGIN_HANDLED
+	}
+	
+	new temp[12]
+	read_argv(1, temp, 11)
+	
+	g_BlockLog = str_to_num(temp) ? true : false
+	
+	return PLUGIN_HANDLED
+}
+
+public plugin_log()
+{
+	server_print("Got log event!  Blocking: %d", g_BlockLog)
+	
+	return g_BlockLog ? PLUGIN_HANDLED : PLUGIN_CONTINUE
+}
+
+public Command_AddLogEvent(id)
+{
+	register_logevent("event_round_start", 2, "0=World triggered", "1=Round_Start")
+	
+	return PLUGIN_HANDLED
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/menutest.sma

@@ -0,0 +1,169 @@
+#include <amxmodx>
+
+public plugin_init()
+{
+	register_plugin("Menu Tests", "1.0", "BAILOPAN")
+
+	register_clcmd("menu_test1", "Test_Menu1")
+	register_clcmd("menu_test2", "Test_Menu2")
+	register_clcmd("menu_test3", "Test_Menu3")
+	register_clcmd("menu_test4", "Test_Menu4")
+	register_clcmd("menu_test5", "Test_Menu5")
+}
+
+public Test_Menu1(id, level, cid)
+{
+	new menu = menu_create("Character Upgrade:", "Test_Menu1_Handler")
+	menu_additem(menu, "Gabezilla 1", "1", 0)
+	menu_additem(menu, "Gabezilla 2", "2", 0)
+	menu_additem(menu, "Gabezilla 3", "3", 0)
+	menu_additem(menu, "Gabezilla 4", "4", 0)
+	menu_additem(menu, "Gabezilla 5", "5", 0)
+	menu_additem(menu, "Gabezilla 6", "6", 0)
+	menu_addblank(menu, 7)
+	menu_additem(menu, "Gabezilla 7", "7", 0)
+	menu_setprop(menu, MPROP_EXIT, MEXIT_NEVER)
+	menu_display(id, menu, 0)
+	return PLUGIN_HANDLED
+}
+
+public Test_Menu2(id, level, cid)
+{
+	new menu = menu_create("Character Upgrade:", "Test_Menu1_Handler")
+	menu_additem(menu, "Gabezilla 1", "1", 0)
+	menu_additem(menu, "Gabezilla 2", "2", 0)
+	menu_additem(menu, "Gabezilla 3", "3", 0)
+	menu_additem(menu, "Gabezilla 4", "4", 0)
+	menu_additem(menu, "Gabezilla 5", "5", 0)
+	menu_additem(menu, "Gabezilla 6", "6", 0)
+	menu_display(id, menu, 0)
+	return PLUGIN_HANDLED
+}
+
+public Test_Menu1_Handler(id, menu, item)
+{
+	client_print(id, print_chat, "Menu (%d->%d): Chose %d", menu, id, item)
+	if (item == MENU_EXIT)
+	{
+		menu_destroy(menu)
+		return PLUGIN_HANDLED
+	}
+	
+	new cmd[32], name[32], access
+	
+	menu_item_getinfo(menu, item, access, cmd, 31, name, 31, access)
+	
+	client_print(id, print_chat, "Menu resolved to: %s (%s)", name, cmd)
+	
+	menu_destroy(menu)
+	
+	return PLUGIN_HANDLED
+}
+
+public Test_Menu3(id)
+{
+   new mHandleID = menu_create("Test Menu 3", "Test_Menu3_Handler")
+   menu_additem(mHandleID, "test1", "1", 0)
+   menu_additem(mHandleID, "test2", "2", 0)
+   menu_additem(mHandleID, "test3", "3", 0)
+   menu_additem(mHandleID, "test4", "4", 0)
+   menu_additem(mHandleID, "test5", "5", 0)
+   menu_additem(mHandleID, "test6", "6", 0)
+   menu_additem(mHandleID, "test7", "7", 0)
+   menu_additem(mHandleID, "test8", "8", 0)
+   menu_additem(mHandleID, "test9", "9", 0)
+   menu_additem(mHandleID, "test10", "10", 0)
+   menu_additem(mHandleID, "test11", "11", 0)
+   menu_addblank(mHandleID, 1)  // add blank got problem
+   menu_setprop(mHandleID, MPROP_PERPAGE, 5)
+
+   menu_display(id, mHandleID, 0)
+   
+   return PLUGIN_HANDLED
+}
+
+public Test_Menu3_Handler(id, menu, item)
+{
+   if (item == MENU_EXIT)
+   {
+	   menu_destroy(menu)
+	   return PLUGIN_HANDLED
+   }
+   
+   client_print(id, print_chat, "item = %d", item)
+   
+   menu_destroy(menu)
+   
+   return PLUGIN_HANDLED
+}
+
+public Test_Menu4(id)
+{
+   new mHandleID = menu_create("Test Menu 4", "Test_Menu4_Handler")
+   menu_setprop(mHandleID, MPROP_PERPAGE, 0)
+   menu_additem(mHandleID, "test1", "1", 0)
+   menu_additem(mHandleID, "test2", "2", 0)
+   menu_additem(mHandleID, "test3", "3", 0)
+   menu_additem(mHandleID, "test4", "4", 0)
+   menu_additem(mHandleID, "test5", "5", 0)
+   menu_additem(mHandleID, "test6", "6", 0)
+   menu_additem(mHandleID, "test7", "7", 0)
+   menu_additem(mHandleID, "test8", "8", 0)
+   menu_additem(mHandleID, "test9", "9", 0)
+
+   menu_display(id, mHandleID, 0)
+   
+   return PLUGIN_HANDLED
+}
+
+public Test_Menu4_Handler(id, menu, item)
+{
+   if (item == MENU_EXIT)
+   {
+	   menu_destroy(menu)
+	   return PLUGIN_HANDLED
+   }
+   
+   client_print(id, print_chat, "item = %d", item)
+   
+   menu_destroy(menu)
+   
+   return PLUGIN_HANDLED
+}
+
+public Test_Menu5(id)
+{
+   new mHandleID = menu_create("Test Menu 5", "Test_Menu5_Handler")
+   menu_additem(mHandleID, "test1", "1", 0)
+   menu_additem(mHandleID, "test2", "2", 0)
+   menu_additem(mHandleID, "test3", "3", 0)
+   menu_additem(mHandleID, "test4", "4", 0)
+   menu_additem(mHandleID, "test5", "5", 0)
+   menu_additem(mHandleID, "test6", "6", 0)
+   menu_additem(mHandleID, "test7", "7", 0)
+   menu_additem(mHandleID, "test8", "8", 0)
+   menu_additem(mHandleID, "test9", "9", 0)
+   menu_additem(mHandleID, "test10", "10", 0)
+   menu_additem(mHandleID, "test11", "11", 0)
+   menu_addblank(mHandleID, 1)  // add blank got problem
+   menu_setprop(mHandleID, MPROP_EXIT, MEXIT_NEVER)
+
+   menu_display(id, mHandleID, 0)
+   
+   return PLUGIN_HANDLED
+}
+
+public Test_Menu5_Handler(id, menu, item)
+{
+   if (item == MENU_EXIT)
+   {
+	   menu_destroy(menu)
+	   return PLUGIN_HANDLED
+   }
+   
+   client_print(id, print_chat, "item = %d", item)
+   
+   menu_destroy(menu)
+   
+   return PLUGIN_HANDLED
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/native_test.sma

@@ -0,0 +1,31 @@
+#include <amxmodx>
+
+native Factorial(num)
+
+public __Factorial(id, num)
+{
+	new num = get_param(1)
+	if (num == 0)
+	{
+		return 1
+	}
+	
+	return num * Factorial(num - 1)
+}
+
+public plugin_natives()
+{
+	register_native("Factorial", "__Factorial")
+}
+
+public plugin_init()
+{
+	register_plugin("Native Test", "1.0", "BAILOPAN")
+	register_srvcmd("test_native1", "Command_TestNative1")
+}
+
+public Command_TestNative1()
+{
+	new num = Factorial(6)
+	server_print("Factorial of 6 is: %d", num)
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/nvault_test.sma

@@ -0,0 +1,20 @@
+#include <amxmodx>
+#include <nvault>
+
+public plugin_init()
+{
+	register_plugin("nVault Test", "1.0", "BAILOPAN")
+	
+	register_srvcmd("test_nvault", "Command_TestNvault")
+}
+
+public Command_TestNvault()
+{
+	new v = nvault_open("://:/1/R!?#@41345$%:$")
+	server_print("Vault value: %d (expected: %d)", v, -1)
+	
+	if (v != -1)
+	{
+		nvault_close(v)
+	}
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/sorttest.sma

@@ -0,0 +1,153 @@
+#include <amxmodx>
+
+public plugin_init()
+{
+	register_plugin("Sort Test", "1.0", "BAILOPAN")
+	
+	register_srvcmd("test_sort_ints", "Command_TestSortInts")
+	register_srvcmd("test_sort_floats", "Command_TestSortFloats")
+	register_srvcmd("test_sort_strings", "Command_TestSortStrings")
+	register_srvcmd("test_sort_1d", "Command_TestSort1D")
+	register_srvcmd("test_sort_2d", "Command_TestSort2D")
+}
+
+/*****************
+ * INTEGER TESTS *
+ *****************/
+// Note that integer comparison is just int1-int2 (or a variation therein)
+
+PrintIntegers(const array[], size)
+{
+	for (new i=0; i<size; i++)
+	{
+		server_print("array[%d] = %d", i, array[i])
+	}
+}
+
+public Command_TestSortInts()
+{
+	new array[10] = {6, 7, 3, 2, 8, 5, 0, 1, 4, 9}
+	
+	server_print("Testing ascending sort:")
+	SortIntegers(array, 10, Sort_Ascending)
+	PrintIntegers(array, 10)
+	
+	server_print("Testing descending sort:")
+	SortIntegers(array, 10, Sort_Descending)
+	PrintIntegers(array, 10)
+}
+
+/**************************
+ * Float comparison tests *
+ **************************/
+
+PrintFloats(const Float:array[], size)
+{
+	for (new i=0; i<size; i++)
+	{
+		server_print("array[%d] = %f", i, array[i])
+	}
+}
+
+public Command_TestSortFloats()
+{
+	new Float:array[10] = {6.3, 7.6, 3.2, 2.1, 8.5, 5.2, 0.4, 1.7, 4.8, 8.2}
+	
+	server_print("Testing ascending sort:")
+	SortFloats(array, 10, Sort_Ascending)
+	PrintFloats(array, 10)
+	
+	server_print("Testing descending sort:")
+	SortFloats(array, 10, Sort_Descending)
+	PrintFloats(array, 10)
+	
+	return PLUGIN_HANDLED
+}
+
+public Custom1DSort(Float:elem1, Float:elem2)
+{
+	if (elem1 > elem2)
+	{
+		return -1;
+	} else if (elem1 < elem2) {
+		return 1;
+	}
+	
+	return 0;
+}
+
+public Command_TestSort1D()
+{
+	new Float:array[10] = {6.3, 7.6, 3.2, 2.1, 8.5, 5.2, 0.4, 1.7, 4.8, 8.2}
+	
+	SortCustom1D(_:array, 10, "Custom1DSort")
+	PrintFloats(array, 10)
+	
+	return PLUGIN_HANDLED
+}
+
+/***************************
+ * String comparison tests *
+ ***************************/
+
+PrintStrings(const array[][], size)
+{
+	for (new i=0; i<size; i++)
+	{
+		server_print("array[%d] = %s", i, array[i])
+	}
+}
+
+public Command_TestSortStrings()
+{
+	new array[][] = 
+		{
+			"faluco",
+			"bailopan",
+			"pm onoto",
+			"damaged soul",
+			"sniperbeamer",
+			"sidluke",
+			"johnny got his gun",
+			"gabe newell",
+			"hello",
+			"WHAT?!"
+		}
+		
+	server_print("Testing ascending sort:")
+	SortStrings(array, 10, Sort_Ascending)
+	PrintStrings(array, 10)
+	
+	server_print("Testing descending sort:")
+	SortStrings(array, 10, Sort_Descending)
+	PrintStrings(array, 10)
+	
+	return PLUGIN_HANDLED
+}
+
+public Custom2DSort(const elem1[], const elem2[])
+{
+	return strcmp(elem1, elem2)
+}
+
+public Command_TestSort2D()
+{
+	new array[][] = 
+		{
+			"faluco",
+			"bailopan",
+			"pm onoto",
+			"damaged soul",
+			"sniperbeamer",
+			"sidluke",
+			"johnny got his gun",
+			"gabe newell",
+			"hello",
+			"WHAT?!"
+		}
+	
+	SortCustom2D(array, 10, "Custom2DSort")
+	PrintStrings(array, 10)
+	
+	return PLUGIN_HANDLED
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/sqlxtest.sma

@@ -0,0 +1,412 @@
+#include <amxmodx>
+#include <amxmisc>
+#include <dbi>
+#include <sqlx>
+
+new Handle:g_DbInfo
+new g_QueryNum
+new bool:g_TestEnd = false
+
+public plugin_init()
+{
+	register_plugin("SQLX Test", "1.0", "BAILOPAN")
+	register_srvcmd("sqlx_test_normal", "SqlxTest_Normal")
+	register_srvcmd("sqlx_test_thread", "SqlxTest_Thread")
+	register_srvcmd("sqlx_test_proc", "SqlxTest_Proc")
+	register_srvcmd("sqlx_test_old1", "SqlxTest_Old1")
+	register_srvcmd("sqlx_test_old2", "SqlxTest_Old2")
+	register_srvcmd("sqlx_test_thread_end", "SqlxTest_ThreadEnd")
+	register_srvcmd("sqlx_test_bad", "SqlxTest_Bad")
+	register_srvcmd("sqlx_test_quote", "SqlxTest_Quote")
+	register_srvcmd("sqlx_test_affinity", "SqlxTest_Affinity")
+	
+	new configsDir[64]
+	get_configsdir(configsDir, 63)
+	
+	server_cmd("exec %s/sql.cfg", configsDir)
+	
+	set_task(2.0, "start_map")
+}
+
+DoBasicInfo(affinities=0)
+{
+	new type[12]
+	new affinity[12]
+	new wanted_type[12]
+	
+	dbi_type(type, 11)
+	
+	server_print("DBI type: %s", type)
+	
+	if (!affinities)
+		return
+	
+	SQL_GetAffinity(affinity, 11);
+	server_print("SQLX Affinity: %s", affinity)
+	
+	get_cvar_string("amx_sql_type", wanted_type, 11)
+	if (!equal(wanted_type, affinity))
+	{
+		if (g_DbInfo)
+		{
+			SQL_FreeHandle(g_DbInfo)
+			g_DbInfo = Empty_Handle
+		}
+		new res = SQL_SetAffinity(wanted_type)
+		server_print("Setting affinity from %s to %s: %s", 
+			affinity,
+			wanted_type,
+			res ? "Success" : "Failed")
+		SQL_GetAffinity(affinity, 11)
+		start_map()
+		server_print("Verification: %s", affinity)
+	}
+}
+
+public start_map()
+{
+	new host[64]
+	new user[64]
+	new pass[64]
+	new db[64]
+	
+	get_cvar_string("amx_sql_host", host, 63)
+	get_cvar_string("amx_sql_user", user, 63)
+	get_cvar_string("amx_sql_pass", pass, 63)
+	get_cvar_string("amx_sql_db", db, 63)
+	
+	g_DbInfo = SQL_MakeDbTuple(host, user, pass, db)
+}
+
+public SqlxTest_Bad()
+{
+	new errnum, error[255]
+	new Handle:tempinfo = SQL_MakeDbTuple("1.2.3.4", "asdf", "gasdf", "gaben", 2)
+	new Handle:db = SQL_Connect(tempinfo, errnum, error, 254)
+	
+	if (db == Empty_Handle)
+	{
+		server_print(" --> Errored out! %d, %s", errnum, error)
+	} else {
+		server_print(" --> Something is wrong here.")
+	}
+	
+	return PLUGIN_HANDLED
+}
+
+/**
+ * Note that this function works for both threaded and non-threaded queries.
+ */
+PrintQueryData(Handle:query)
+{
+	new columns = SQL_NumColumns(query)
+	new rows = SQL_NumResults(query)
+	static querystring[2048]
+	
+	SQL_GetQueryString(query, querystring, 2047)
+	
+	server_print("Original query string: %s", querystring)
+	server_print("Query columns: %d rows: %d", columns, rows)
+	
+	new num
+	new row
+	new str[32]
+	new cols[2][32]
+	SQL_FieldNumToName(query, 0, cols[0], 31)
+	SQL_FieldNumToName(query, 1, cols[1], 31)
+	while (SQL_MoreResults(query))
+	{
+		num = SQL_ReadResult(query, 0)
+		SQL_ReadResult(query, 1, str, 31)
+		server_print("[%d]: %s=%d, %s=%s", row, cols[0], num, cols[1], str)
+		SQL_NextRow(query)
+		row++
+	}
+}
+
+/**
+ * Handler for when a threaded query is resolved.
+ */
+public GetMyStuff(failstate, Handle:query, error[], errnum, data[], size, Float:queuetime)
+{
+	server_print(" --> Resolved query %d, took %f seconds", data[0], queuetime)
+	if (failstate)
+	{
+		if (failstate == TQUERY_CONNECT_FAILED)
+		{
+			server_print(" --> Connection failed!")
+		} else if (failstate == TQUERY_QUERY_FAILED) {
+			server_print(" --> Query failed!")
+		}
+		server_print(" --> Error code: %d (Message: ^"%s^")", errnum, error)
+		
+		new querystring[1024]
+		SQL_GetQueryString(query, querystring, 1023)
+		server_print(" --> Original query: %s", querystring)
+	} else {
+		PrintQueryData(query)
+	}
+}
+
+public SqlxTest_Affinity()
+{
+	server_print("[Access Manager] try SetAffinity to sqlite");
+	SQL_SetAffinity("sqlite");
+	server_print("[Access Manager] try SetAffinity to mysql");
+	SQL_SetAffinity("mysql");
+	server_print("[Access Manager] try SetAffinity to sqlite again");
+	SQL_SetAffinity("sqlite");
+}
+
+/**
+ * Starts a threaded query.
+ */
+public SqlxTest_Thread()
+{
+	new query[512]
+	new data[1]
+	
+	data[0] = g_QueryNum
+	format(query, 511, "SELECT * FROM gaben")
+	
+	DoBasicInfo(1)
+	
+	server_print("Adding to %d queue at: %f", g_QueryNum, get_gametime())
+	SQL_ThreadQuery(g_DbInfo, "GetMyStuff", query, data, 1)
+	
+	g_QueryNum++
+}
+
+/**
+ * Tests string quoting
+ */
+public SqlxTest_Quote()
+{
+	DoBasicInfo(1)
+	
+	new errno, error[255]
+	
+	new Handle:db = SQL_Connect(g_DbInfo, errno, error, sizeof(error)-1)
+	if (!db)
+	{
+		server_print("Query failure: [%d] %s", errno, error)
+		return
+	}
+	
+	new buffer[500], num
+	num = SQL_QuoteString(db, buffer, sizeof(buffer)-1, "Hi y'all! C\lam")
+	
+	server_print("num: %d str: %s", num, buffer)
+	
+	SQL_FreeHandle(db)
+}
+
+public SqlxTest_Proc()
+{
+	new errnum, error[255]
+	
+	DoBasicInfo(1)
+	
+	new Handle:db = SQL_Connect(g_DbInfo, errnum, error, 254)
+	if (!db)
+	{
+		server_print("Query failure: [%d] %s", errnum, error)
+		return
+	}
+	
+	new Handle:query = SQL_PrepareQuery(db, "CALL ExampleProc()")
+	if (!SQL_Execute(query))
+	{
+		errnum = SQL_QueryError(query, error, 254)
+		server_print("Query failure: [%d] %s", errnum, error)
+		SQL_FreeHandle(query)
+		SQL_FreeHandle(db)
+		return
+	}
+
+	PrintQueryData(query)	
+	
+	server_print("Next result: %d", SQL_NextResultSet(query));
+	
+	PrintQueryData(query)
+	
+	SQL_FreeHandle(query)
+	SQL_FreeHandle(db)
+}
+
+/**
+ * Does a normal query.
+ */
+public SqlxTest_Normal()
+{
+	new errnum, error[255]
+	
+	DoBasicInfo(1)
+	
+	new Handle:db = SQL_Connect(g_DbInfo, errnum, error, 254)
+	if (!db)
+	{
+		server_print("Query failure: [%d] %s", errnum, error)
+		return
+	}
+	
+	new Handle:query = SQL_PrepareQuery(db, "SELECT * FROM gaben")
+	if (!SQL_Execute(query))
+	{
+		errnum = SQL_QueryError(query, error, 254)
+		server_print("Query failure: [%d] %s", errnum, error)
+		SQL_FreeHandle(query)
+		SQL_FreeHandle(db)
+		return
+	}
+
+	PrintQueryData(query)	
+	
+	server_print("Next result: %d", SQL_NextResultSet(query));
+	
+	SQL_FreeHandle(query)
+	SQL_FreeHandle(db)
+}
+
+/**
+ * Wrapper for an old-style connection.
+ */
+Sql:OldInitDatabase()
+{
+	new host[64]
+	new user[64]
+	new pass[64]
+	new db[64]
+	
+	get_cvar_string("amx_sql_host", host, 63)
+	get_cvar_string("amx_sql_user", user, 63)
+	get_cvar_string("amx_sql_pass", pass, 63)
+	get_cvar_string("amx_sql_db", db, 63)
+	
+	new error[255]
+	new Sql:sql = dbi_connect(host, user, pass, db, error, 254)
+	if (sql < SQL_OK)
+	{
+		server_print("Connection failure: %s", error)
+		return SQL_FAILED
+	}
+	
+	return sql
+}
+
+/**
+ * Tests index-based lookup
+ */
+public SqlxTest_Old1()
+{
+	DoBasicInfo()
+	new Sql:sql = OldInitDatabase()
+	if (sql < SQL_OK)
+		return
+		
+	new Result:res = dbi_query(sql, "SELECT * FROM gaben")
+	
+	if (res == RESULT_FAILED)
+	{
+		new error[255]
+		new code = dbi_error(sql, error, 254)
+		server_print("Result failed! [%d]: %s", code, error)
+	} else if (res == RESULT_NONE) {
+		server_print("No result set returned.")
+	} else {
+		new cols[2][32]
+		new str[32]
+		new row, num
+		new rows = dbi_num_rows(res)
+		new columns = dbi_num_fields(res)
+		
+		dbi_field_name(res, 1, cols[0], 31)
+		dbi_field_name(res, 2, cols[1], 31)
+		server_print("Query columns: %d rows: %d", columns, rows)
+		while (dbi_nextrow(res) > 0)
+		{
+			num = dbi_field(res, 1)
+			dbi_field(res, 2, str, 31)
+			server_print("[%d]: %s=%d, %s=%s", row, cols[0], num, cols[1], str)
+			row++
+		}
+		dbi_free_result(res)
+	}
+		
+	dbi_close(sql)
+}
+
+
+/**
+ * Tests name-based lookup
+ */
+public SqlxTest_Old2()
+{
+	DoBasicInfo()
+	new Sql:sql = OldInitDatabase()
+	if (sql < SQL_OK)
+		return
+		
+	new Result:res = dbi_query(sql, "SELECT * FROM gaben")
+	
+	if (res == RESULT_FAILED)
+	{
+		new error[255]
+		new code = dbi_error(sql, error, 254)
+		server_print("Result failed! [%d]: %s", code, error)
+	} else if (res == RESULT_NONE) {
+		server_print("No result set returned.")
+	} else {
+		new cols[2][32]
+		new str[32]
+		new row, num
+		new rows = dbi_num_rows(res)
+		new columns = dbi_num_fields(res)
+		
+		dbi_field_name(res, 1, cols[0], 31)
+		dbi_field_name(res, 2, cols[1], 31)
+		server_print("Query columns: %d rows: %d", columns, rows)
+		while (dbi_nextrow(res) > 0)
+		{
+			num = dbi_result(res, cols[0])
+			dbi_result(res, cols[1], str, 31)
+			server_print("[%d]: %s=%d, %s=%s", row, cols[0], num, cols[1], str)
+			row++
+		}
+		dbi_free_result(res)
+	}
+		
+	dbi_close(sql)
+}
+
+public SqlxTest_ThreadEnd()
+{
+	if (read_argc() < 2)
+	{
+		server_print("Requires mapname!")
+	} else {
+		new mapname[64]
+		
+		read_argv(1, mapname, 63)
+		if (!is_map_valid(mapname))
+		{
+			server_print("Invalid map: %s", mapname)
+		} else {
+			g_TestEnd = true
+			server_cmd("changelevel %s", mapname)
+		}
+	}
+	
+	return PLUGIN_HANDLED
+}
+
+
+public plugin_end()
+{
+	if (g_TestEnd)
+	{
+		SqlxTest_Thread()
+	} else {
+		SQL_FreeHandle(g_DbInfo)
+	}
+}

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/sqlxtest.sql

@@ -0,0 +1,8 @@
+
+
+CREATE TABLE gaben (gaben int primary key, fat varchar(32));
+
+INSERT INTO gaben VALUES(1, 'what the');
+INSERT INTO gaben VALUES(2, 'Bee''s Knees!');
+INSERT INTO gaben VALUES(3, 'newell');
+INSERT INTO gaben VALUES(4, 'CRAB CAKE.');

serverfiles/cstrike/addons/amxmodx/scripting/testsuite/trietest.sma

@@ -0,0 +1,169 @@
+#include <amxmodx>
+
+
+// These natives are only available in a debug build of amxmodx
+native TrieFreeCount();
+native TrieMallocCount();
+
+new failcount = 0;
+new passcount = 0;
+public plugin_init()
+{
+	register_plugin("Trie Test", AMXX_VERSION_STR, "AMXX Dev Team");
+	register_srvcmd("trietest", "trietest");
+}
+
+stock fail(const testname[])
+{
+	server_print("[FAIL] %s", testname);
+
+	failcount++;
+}
+stock pass(const testname[])
+{
+	server_print("[PASS] %s", testname);
+
+	passcount++;
+}
+stock done()
+{
+	server_print("Finished. %d tests, %d failed", failcount + passcount, failcount);
+}
+stock check_frees()
+{
+	if (TrieMallocCount() != TrieFreeCount())
+		fail("free count == malloc count");
+
+	else
+		pass("free count == malloc count");
+
+	server_print("malloc count: %d free count: %d", TrieMallocCount(), TrieFreeCount());
+}
+public trietest()
+{
+	failcount = 0;
+	passcount = 0;
+
+	new bool:ok = true;
+	new Trie:t = TrieCreate();
+
+	new Trie:oldhandle = t; // Makes sure that the trie handle system recycles old handles
+
+	new key[32];
+	for (new i = 0; i < 100; i++)
+	{
+		formatex(key, charsmax(key), "K%dK", i);
+		TrieSetCell(t, key, i);
+	}
+	
+	for (new i = 0; i < 100; i++)
+	{
+		formatex(key, charsmax(key), "K%dK", i);
+		new val;
+		if (!TrieGetCell(t, key, val))
+		{
+			server_print("TrieGetCell(%d, '%s', %d) failed", t, key, val);
+			ok = false;
+		}
+
+		else if (val != i)
+		{
+			server_print("val mismatch, expected: %d got: %d", i, val);
+			ok = false;
+		}
+
+	}
+	if (ok)
+		pass("Cell tests");
+
+	else
+		fail("Cell tests");
+
+	TrieClear(t);
+	TrieDestroy(t);
+
+	t = TrieCreate();
+
+	if (t == oldhandle)
+		pass("Recycle handles");
+
+	else
+		fail("Recycle handles");
+
+	ok = true;
+	for (new i = 0; i < 100; i++)
+	{
+		static val[32];
+		formatex(key, charsmax(key), "K%dK", i);
+		formatex(val, charsmax(val), "V%dV", i);
+		TrieSetString(t, key, val);
+	}
+	
+	for (new i = 0; i < 100; i++)
+	{
+		formatex(key, charsmax(key), "K%dK", i);
+		static val[32];
+		static exp[32];
+		formatex(exp, charsmax(exp), "V%dV", i);
+		if (!TrieGetString(t, key, val, charsmax(val)))
+		{
+			server_print("TrieGetString(%d, '%s', %s) failed", t, key, val);
+			ok = false;
+		}
+
+		else if (!equal(val, exp))
+		{
+			server_print("val mismatch, key: '%s' expected: '%s' got: '%s'", key, exp, val);
+			ok = false;
+		}
+
+	}
+	if (ok)
+		pass("String tests");
+
+	else
+		fail("String tests");
+
+	TrieDestroy(t);
+
+	check_frees();
+
+	t = TrieCreate();
+	ok = true;
+	for (new i = 0; i < 1000; i++)
+	{
+		formatex(key, charsmax(key), "!%d!", i);
+		TrieSetString(t, key, key);
+	}
+	for (new i = 0; i < 1000; i++)
+	{
+		formatex(key, charsmax(key), "!%d!", i);
+
+		if (!TrieKeyExists(t, key))
+		{
+			ok = false;
+			server_print("Key '%s' does not exist", key);
+		}
+		else
+		{
+			if (!TrieDeleteKey(t, key))
+			{
+				server_print("Key '%s' could not be deleted", key);
+				ok = false;
+			}
+		}
+	}
+	if (ok)
+		pass("Exists/Delete");
+
+	else
+		fail("Exists/Delete");
+
+	check_frees();
+	TrieClear(t);
+	TrieDestroy(t);
+	check_frees();
+	done();
+	
+}
+