1 files changed, 183 insertions, 0 deletions
diff --git a/test/common/hash-str.h b/test/common/hash-str.h
new file mode 100644
index 0000000000..b106f66eda
--- /dev/null
+++ b/test/common/hash-str.h
@@ -0,0 +1,183 @@
+#include <cxxtest/TestSuite.h>
+#include "common/hash-str.h"
+
+/**
+ * Test suite for common/hash-str.h
+ * We test a number of case sensitive/insensitive hash and compare functions
+ * using example strings and known hashes, trying to tackle
+ * as much edge cases as possible.
+ */
+class HashStrTestSuite : public CxxTest::TestSuite {
+
+	public:
+	void test_case_sensitive_string_equal_to() {
+
+		// Name says it all.
+		// This verifies that the function returns true
+		// for exactly the same string, false for the same
+		// string in mixed case and false for some edge cases
+		// with various spacings plus one character replaced
+		// by itself+128 (if there's some processing done after
+		// conversion to 7-bit ASCII this might yield funny results).
+
+		const Common::String lower("test");
+		const Common::String lower1("test");
+		const Common::String mixed("tESt");
+		const Common::String spaced("test ");
+		const Common::String doublespaced("test  ");
+		const Common::String tabbed("test\t");
+		const Common::String plus128("t\xE5est");
+		// 'e'+128 = 0xE5
+
+		Common::CaseSensitiveString_EqualTo css_et;
+		TS_ASSERT_EQUALS(css_et(lower, mixed), false);
+		TS_ASSERT_EQUALS(css_et(lower, lower1), true);
+		TS_ASSERT_EQUALS(css_et(lower, lower), true);
+
+		// Different sorts of whitespace are to be treated differently.
+		TS_ASSERT_EQUALS(css_et(lower, spaced), false);
+		TS_ASSERT_EQUALS(css_et(lower, tabbed), false);
+		TS_ASSERT_EQUALS(css_et(spaced, tabbed), false);
+		TS_ASSERT_EQUALS(css_et(spaced, doublespaced), false);
+		TS_ASSERT_EQUALS(css_et(lower, plus128), false);
+	}
+
+	void test_ignore_case_equal_to() {
+
+		// This should be probably called case_insensitive_string_equal_to
+		// or something,but it's basically the same thing as
+		// test_case_sensitive_string_equal_to, only it's case
+		// insensitive.
+
+		const Common::String lower("test");
+		const Common::String lower1("test");
+		const Common::String mixed("tESt");
+		const Common::String spaced("test ");
+		const Common::String mixedspaced("tESt ");
+		const Common::String doublespaced("test  ");
+		const Common::String tabbed("test\t");
+		const Common::String plus128("t\xE5est");
+
+		Common::IgnoreCase_EqualTo ic_et;
+		TS_ASSERT_EQUALS(ic_et(lower, mixed), true);
+		TS_ASSERT_EQUALS(ic_et(lower, lower1), true);
+		TS_ASSERT_EQUALS(ic_et(lower, lower), true);
+		// Edge case:
+		TS_ASSERT_EQUALS(ic_et(spaced, mixedspaced), true);
+
+		// Different sorts of whitespace are to be treated differently.
+		TS_ASSERT_EQUALS(ic_et(lower, spaced), false);
+		TS_ASSERT_EQUALS(ic_et(lower, tabbed), false);
+		TS_ASSERT_EQUALS(ic_et(spaced, tabbed), false);
+		TS_ASSERT_EQUALS(ic_et(spaced, doublespaced), false);
+		TS_ASSERT_EQUALS(ic_et(lower, plus128), false);
+	}
+
+	void test_case_sensitive_string_hash() {
+
+		// Here we compute string hashes for different
+		// strings and see that the functor is case sensitive
+		// and does not ignore spaces.
+		// The hashes come from Python's hash() function.
+
+		const Common::String lower("test");
+		const uint lower_hash = 1308370872;
+		const Common::String lower1("test");
+		const Common::String mixed("tESt");
+		const uint mixed_hash = -1217273608;
+		const Common::String spaced("test ");
+		const uint spaced_hash = -1086267887;
+		const Common::String mixedspaced("tESt ");
+		const Common::String doublespaced("test  ");
+		const Common::String tabbed("test\t");
+		const uint tabbed_hash = -1086267848;
+
+		Common::CaseSensitiveString_Hash css_h;
+		TS_ASSERT_EQUALS(css_h(lower), lower_hash);
+		TS_ASSERT_EQUALS(css_h(mixed), mixed_hash);
+		TS_ASSERT_EQUALS(css_h(spaced), spaced_hash);
+		TS_ASSERT_EQUALS(css_h(tabbed), tabbed_hash);
+		TS_ASSERT_DIFFERS(css_h(spaced), css_h(doublespaced));
+	}
+
+	void test_ignore_case_hash() {
+		// Same as test_case_sensitive_string_hash, but case insensitive.
+		const Common::String lower("test");
+		const uint lower_hash = 1308370872;
+		const Common::String lower1("test");
+		const Common::String mixed("tESt");
+		const Common::String spaced("test ");
+		const uint spaced_hash = -1086267887;
+		const Common::String mixedspaced("tESt ");
+		const Common::String doublespaced("test  ");
+		const Common::String tabbed("test\t");
+		const uint tabbed_hash = -1086267848;
+
+		Common::IgnoreCase_Hash ic_h;
+		TS_ASSERT_EQUALS(ic_h(lower), lower_hash);
+		TS_ASSERT_EQUALS(ic_h(mixed), lower_hash);
+		TS_ASSERT_EQUALS(ic_h(spaced), spaced_hash);
+		TS_ASSERT_EQUALS(ic_h(tabbed), tabbed_hash);
+		TS_ASSERT_EQUALS(ic_h(mixedspaced), spaced_hash);
+		TS_ASSERT_DIFFERS(ic_h(spaced), ic_h(doublespaced));
+	}
+
+	void test_cpp_string_hash ()
+	{
+		// We run the same tests with Hash<String>,
+		// a template specialization of Hash, also a functor.
+		// It is supposed to be case sensitive.
+		// Again, hashes come from Python's hash().
+
+		const Common::String lower("test");
+		const uint lower_hash = 1308370872;
+		const Common::String lower1("test");
+		const Common::String mixed("tESt");
+		const uint mixed_hash = -1217273608;
+		const Common::String spaced("test ");
+		const uint spaced_hash = -1086267887;
+		const Common::String mixedspaced("tESt ");
+		const Common::String doublespaced("test  ");
+		const Common::String tabbed("test\t");
+		const uint tabbed_hash = -1086267848;
+
+		Common::Hash<Common::String> h;
+		TS_ASSERT_EQUALS(h(lower), lower_hash);
+		TS_ASSERT_EQUALS(h(lower), h(lower1));
+		TS_ASSERT_EQUALS(h(mixed), mixed_hash);
+		TS_ASSERT_EQUALS(h(spaced), spaced_hash);
+		TS_ASSERT_EQUALS(h(tabbed), tabbed_hash);
+		TS_ASSERT_DIFFERS(h(spaced), h(doublespaced));
+	}
+
+	void test_c_style_string_hash ()
+	{
+		// Same as test_cpp_string_hash but with Hash<const char*>,
+		// a template specialization of Hash, also a functor,
+		// that works with C-Style strings.
+		// It is supposed to be case sensitive.
+
+		char lower[] = "test";
+		const uint lower_hash = 1308370872; // CPython told me so
+		char lower1[] = "test";
+		char mixed[] = "tESt";
+		const uint mixed_hash = -1217273608;
+		char spaced[] = "test ";
+		const uint spaced_hash = -1086267887;
+		char mixedspaced[] = "tESt ";
+		char doublespaced[] = "test  ";
+		char tabbed[] = "test\t";
+		const uint tabbed_hash = -1086267848;
+
+		Common::Hash<const char*> h;
+		TS_ASSERT_EQUALS(h(lower), lower_hash);
+		TS_ASSERT_EQUALS(h(lower), h(lower1));
+		TS_ASSERT_EQUALS(h(mixed), mixed_hash);
+		TS_ASSERT_EQUALS(h(spaced), spaced_hash);
+		TS_ASSERT_DIFFERS(h(spaced), h(mixedspaced));
+		TS_ASSERT_EQUALS(h(tabbed), tabbed_hash);
+		TS_ASSERT_DIFFERS(h(spaced), h(doublespaced));
+	}
+
+
+};