|
@@ -6,301 +6,290 @@
|
|
|
|
|
|
using String = Core::ArrayString<128>;
|
|
|
|
|
|
-static String build(Core::Test& test, const char* cs) {
|
|
|
+static String build(const char* cs) {
|
|
|
String s;
|
|
|
- test.checkFalse(s.append(cs), "append works");
|
|
|
+ CORE_TEST_FALSE(s.append(cs));
|
|
|
return s;
|
|
|
}
|
|
|
|
|
|
-static void testEquality(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
- test.checkTrue(s == "test", "equality with c-string");
|
|
|
- test.checkTrue(s == build(test, "test"), "equality with another string");
|
|
|
- test.checkTrue("test" == s, "inverse equality with c-string");
|
|
|
- test.checkTrue(build(test, "test") == s,
|
|
|
- "inverse equality with another string");
|
|
|
- test.checkTrue(s == s, "equality with itself");
|
|
|
+static void testEquality() {
|
|
|
+ String s = build("test");
|
|
|
+ CORE_TEST_TRUE(s == "test");
|
|
|
+ CORE_TEST_TRUE(s == build("test"));
|
|
|
+ CORE_TEST_TRUE("test" == s);
|
|
|
+ CORE_TEST_TRUE(build("test") == s);
|
|
|
+ CORE_TEST_TRUE(s == s);
|
|
|
}
|
|
|
|
|
|
-static void testUnicodeEquality(Core::Test& test) {
|
|
|
+static void testUnicodeEquality() {
|
|
|
const char* cs = "\u0040\u0400\u8000\U00100000";
|
|
|
- String s = build(test, cs);
|
|
|
- test.checkTrue(s == cs, "unicode equality with c-string");
|
|
|
- test.checkTrue(s == build(test, cs),
|
|
|
- "unicode equality with another string");
|
|
|
- test.checkTrue(cs == s, "unicode inverse equality with c-string");
|
|
|
- test.checkTrue(build(test, cs) == s,
|
|
|
- "unicode inverse equality with another string");
|
|
|
- test.checkTrue(s == s, "unicode equality with itself");
|
|
|
+ String s = build(cs);
|
|
|
+ CORE_TEST_TRUE(s == cs);
|
|
|
+ CORE_TEST_TRUE(s == build(cs));
|
|
|
+ CORE_TEST_TRUE(cs == s);
|
|
|
+ CORE_TEST_TRUE(build(cs) == s);
|
|
|
+ CORE_TEST_TRUE(s == s);
|
|
|
}
|
|
|
|
|
|
-static void testInequality(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
- test.checkFalse(s != "test", "inequality with c-string");
|
|
|
- test.checkFalse(s != build(test, "test"), "inequality with another string");
|
|
|
- test.checkFalse("test" != s, "inverse inequality with c-string");
|
|
|
- test.checkFalse(build(test, "test") != s,
|
|
|
- "inverse inequality with another string");
|
|
|
- test.checkFalse(s != s, "inequality with itself");
|
|
|
+static void testInequality() {
|
|
|
+ String s = build("test");
|
|
|
+ CORE_TEST_FALSE(s != "test");
|
|
|
+ CORE_TEST_FALSE(s != build("test"));
|
|
|
+ CORE_TEST_FALSE("test" != s);
|
|
|
+ CORE_TEST_FALSE(build("test") != s);
|
|
|
+ CORE_TEST_FALSE(s != s);
|
|
|
}
|
|
|
|
|
|
-static void testStringAppend(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
- test.checkFalse(s.append("22"), "multiple append works");
|
|
|
- test.checkFalse(s.append("333"), "multiple append works");
|
|
|
- test.checkFalse(s.append("4444"), "multiple append works");
|
|
|
- test.checkEqual(build(test, "test223334444"), s, "multiple appends");
|
|
|
+static void testStringAppend() {
|
|
|
+ String s = build("test");
|
|
|
+ CORE_TEST_FALSE(s.append("22"));
|
|
|
+ CORE_TEST_FALSE(s.append("333"));
|
|
|
+ CORE_TEST_FALSE(s.append("4444"));
|
|
|
+ CORE_TEST_EQUAL(build("test223334444"), s);
|
|
|
}
|
|
|
|
|
|
-static void testStringAppendOverflow(Core::Test& test) {
|
|
|
+static void testStringAppendOverflow() {
|
|
|
Core::ArrayString<20> s;
|
|
|
- test.checkFalse(s.append("te"), "overflow test 1");
|
|
|
- test.checkTrue(s.append("23334444"), "overflow test 2");
|
|
|
- test.checkTrue(build(test, "te23334444") != s, "overflow test 3");
|
|
|
+ CORE_TEST_FALSE(s.append("te"));
|
|
|
+ CORE_TEST_TRUE(s.append("23334444"));
|
|
|
+ CORE_TEST_TRUE(build("te23334444") != s);
|
|
|
}
|
|
|
|
|
|
-static void testCharacters(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
- test.checkEqual<u32>('t', s[0], "character read 1");
|
|
|
- test.checkEqual<u32>('e', s[1], "character read 2");
|
|
|
- test.checkEqual<u32>('s', s[2], "character read 3");
|
|
|
- test.checkEqual<u32>('t', s[3], "character read 4");
|
|
|
+static void testCharacters() {
|
|
|
+ String s = build("test");
|
|
|
+ CORE_TEST_EQUAL('t', s[0]);
|
|
|
+ CORE_TEST_EQUAL('e', s[1]);
|
|
|
+ CORE_TEST_EQUAL('s', s[2]);
|
|
|
+ CORE_TEST_EQUAL('t', s[3]);
|
|
|
}
|
|
|
|
|
|
-static void testLength(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
- test.checkEqual(4, s.getLength(), "length 1");
|
|
|
- test.checkFalse(s.append("aaa"), "length append works");
|
|
|
- test.checkEqual(7, s.getLength(), "length 2");
|
|
|
+static void testLength() {
|
|
|
+ String s = build("test");
|
|
|
+ CORE_TEST_EQUAL(4, s.getLength());
|
|
|
+ CORE_TEST_FALSE(s.append("aaa"));
|
|
|
+ CORE_TEST_EQUAL(7, s.getLength());
|
|
|
}
|
|
|
|
|
|
-static void testChar(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testChar() {
|
|
|
+ String s = build("test");
|
|
|
for(char i = 'a'; i < 'd'; i++) {
|
|
|
- test.checkFalse(s.append(i), "char append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "testabc"), s, "char append");
|
|
|
+ CORE_TEST_EQUAL(build("testabc"), s);
|
|
|
}
|
|
|
|
|
|
-static void testSignedChar(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testSignedChar() {
|
|
|
+ String s = build("test");
|
|
|
for(signed char i = 'b'; i < 'e'; i++) {
|
|
|
- test.checkFalse(s.append(i), "signed char append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "testbcd"), s, "signed char append");
|
|
|
+ CORE_TEST_EQUAL(build("testbcd"), s);
|
|
|
}
|
|
|
|
|
|
-static void testUnsignedChar(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testUnsignedChar() {
|
|
|
+ String s = build("test");
|
|
|
for(unsigned char i = 'c'; i < 'f'; i++) {
|
|
|
- test.checkFalse(s.append(i), "unsigned char append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "testcde"), s, "unsigned char append");
|
|
|
+ CORE_TEST_EQUAL(build("testcde"), s);
|
|
|
}
|
|
|
|
|
|
-static void testSignedShort(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testSignedShort() {
|
|
|
+ String s = build("test");
|
|
|
for(signed short i = 100; i < 103; i++) {
|
|
|
- test.checkFalse(s.append(i), "signed short append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test100101102"), s, "signed short append");
|
|
|
+ CORE_TEST_EQUAL(build("test100101102"), s);
|
|
|
}
|
|
|
|
|
|
-static void testUnsignedShort(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testUnsignedShort() {
|
|
|
+ String s = build("test");
|
|
|
for(unsigned short i = 101; i < 104; i++) {
|
|
|
- test.checkFalse(s.append(i), "unsigned short append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test101102103"), s, "unsigned short append");
|
|
|
+ CORE_TEST_EQUAL(build("test101102103"), s);
|
|
|
}
|
|
|
|
|
|
-static void testSignedInt(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testSignedInt() {
|
|
|
+ String s = build("test");
|
|
|
for(signed int i = 102; i < 105; i++) {
|
|
|
- test.checkFalse(s.append(i), "signed int append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test102103104"), s, "signed int append");
|
|
|
+ CORE_TEST_EQUAL(build("test102103104"), s);
|
|
|
}
|
|
|
|
|
|
-static void testUnsignedInt(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testUnsignedInt() {
|
|
|
+ String s = build("test");
|
|
|
for(unsigned int i = 103; i < 106; i++) {
|
|
|
- test.checkFalse(s.append(i), "unsigned int append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test103104105"), s, "unsigned int append");
|
|
|
+ CORE_TEST_EQUAL(build("test103104105"), s);
|
|
|
}
|
|
|
|
|
|
-static void testSignedLong(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testSignedLong() {
|
|
|
+ String s = build("test");
|
|
|
for(signed long i = 104; i < 107; i++) {
|
|
|
- test.checkFalse(s.append(i), "signed long append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test104105106"), s, "signed long append");
|
|
|
+ CORE_TEST_EQUAL(build("test104105106"), s);
|
|
|
}
|
|
|
|
|
|
-static void testUnsignedLong(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testUnsignedLong() {
|
|
|
+ String s = build("test");
|
|
|
for(unsigned long i = 105; i < 108; i++) {
|
|
|
- test.checkFalse(s.append(i), "unsigned long append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test105106107"), s, "unsigned long append");
|
|
|
+ CORE_TEST_EQUAL(build("test105106107"), s);
|
|
|
}
|
|
|
|
|
|
-static void testSignedLongLong(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testSignedLongLong() {
|
|
|
+ String s = build("test");
|
|
|
for(signed long long i = 106; i < 109; i++) {
|
|
|
- test.checkFalse(s.append(i), "signed long long append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test106107108"), s, "signed long long append");
|
|
|
+ CORE_TEST_EQUAL(build("test106107108"), s);
|
|
|
}
|
|
|
|
|
|
-static void testUnsignedLongLong(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testUnsignedLongLong() {
|
|
|
+ String s = build("test");
|
|
|
for(unsigned long long i = 107; i < 110; i++) {
|
|
|
- test.checkFalse(s.append(i), "unsigned long long append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test107108109"), s,
|
|
|
- "unsigned long long append");
|
|
|
+ CORE_TEST_EQUAL(build("test107108109"), s);
|
|
|
}
|
|
|
|
|
|
-static void testFloat(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testFloat() {
|
|
|
+ String s = build("test");
|
|
|
for(float i = 108; i < 111; i++) {
|
|
|
- test.checkFalse(s.append(i), "float append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test108.00109.00110.00"), s, "float append");
|
|
|
+ CORE_TEST_EQUAL(build("test108.00109.00110.00"), s);
|
|
|
}
|
|
|
|
|
|
-static void testDouble(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testDouble() {
|
|
|
+ String s = build("test");
|
|
|
for(double i = 109; i < 112; i++) {
|
|
|
- test.checkFalse(s.append(i), "double append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test109.00110.00111.00"), s, "double append");
|
|
|
+ CORE_TEST_EQUAL(build("test109.00110.00111.00"), s);
|
|
|
}
|
|
|
|
|
|
-static void testLongDouble(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
+static void testLongDouble() {
|
|
|
+ String s = build("test");
|
|
|
for(long double i = 110; i < 113; i++) {
|
|
|
- test.checkFalse(s.append(i), "long double append");
|
|
|
+ CORE_TEST_FALSE(s.append(i));
|
|
|
}
|
|
|
- test.checkEqual(build(test, "test110.00111.00112.00"), s,
|
|
|
- "long double append");
|
|
|
+ CORE_TEST_EQUAL(build("test110.00111.00112.00"), s);
|
|
|
}
|
|
|
|
|
|
-static void testBool(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
- test.checkFalse(s.append(true), "bool append 1");
|
|
|
- test.checkFalse(s.append(false), "bool append 2");
|
|
|
- test.checkFalse(s.append(true), "bool append 3");
|
|
|
- test.checkEqual(build(test, "testtruefalsetrue"), s, "bool append 4");
|
|
|
+static void testBool() {
|
|
|
+ String s = build("test");
|
|
|
+ CORE_TEST_FALSE(s.append(true));
|
|
|
+ CORE_TEST_FALSE(s.append(false));
|
|
|
+ CORE_TEST_FALSE(s.append(true));
|
|
|
+ CORE_TEST_EQUAL(build("testtruefalsetrue"), s);
|
|
|
}
|
|
|
|
|
|
-static void testIntOverflow(Core::Test& test) {
|
|
|
+static void testIntOverflow() {
|
|
|
Core::ArrayString<20> s;
|
|
|
- test.checkTrue(s.append(123456), "int overflow");
|
|
|
+ CORE_TEST_TRUE(s.append(123456));
|
|
|
|
|
|
String o;
|
|
|
for(int i = 0; i < s.getCapacity(); i++) {
|
|
|
- test.checkFalse(o.append(i + 1), "int overflow compare build");
|
|
|
+ CORE_TEST_FALSE(o.append(i + 1));
|
|
|
}
|
|
|
|
|
|
- test.checkTrue(o == s, "int overflow compare");
|
|
|
+ CORE_TEST_TRUE(o == s);
|
|
|
}
|
|
|
|
|
|
-static void testUnicode(Core::Test& test) {
|
|
|
+static void testUnicode() {
|
|
|
String s;
|
|
|
- test.checkFalse(s.appendUnicode('\u0040'), "unicode 1");
|
|
|
- test.checkFalse(s.appendUnicode(L'\u0400'), "unicode 2");
|
|
|
- test.checkFalse(s.appendUnicode(L'\u8000'), "unicode 3");
|
|
|
- test.checkFalse(s.appendUnicode(U'\U00100000'), "unicode 4");
|
|
|
- test.checkEqual(build(test, "\u0040\u0400\u8000\U00100000"), s,
|
|
|
- "unicode append");
|
|
|
+ CORE_TEST_FALSE(s.appendUnicode('\u0040'));
|
|
|
+ CORE_TEST_FALSE(s.appendUnicode(L'\u0400'));
|
|
|
+ CORE_TEST_FALSE(s.appendUnicode(L'\u8000'));
|
|
|
+ CORE_TEST_FALSE(s.appendUnicode(U'\U00100000'));
|
|
|
+ CORE_TEST_EQUAL(build("\u0040\u0400\u8000\U00100000"), s);
|
|
|
}
|
|
|
|
|
|
-static void testClear(Core::Test& test) {
|
|
|
- String s = build(test, "test");
|
|
|
- test.checkFalse(s.append(1234), "clear 1");
|
|
|
+static void testClear() {
|
|
|
+ String s = build("test");
|
|
|
+ CORE_TEST_FALSE(s.append(1234));
|
|
|
s.clear();
|
|
|
- test.checkFalse(s.append("wusi"), "clear 2");
|
|
|
- test.checkFalse(s.append("1234"), "clear 3");
|
|
|
- test.checkEqual(build(test, "wusi1234"), s, "clear 4");
|
|
|
+ CORE_TEST_FALSE(s.append("wusi"));
|
|
|
+ CORE_TEST_FALSE(s.append("1234"));
|
|
|
+ CORE_TEST_EQUAL(build("wusi1234"), s);
|
|
|
}
|
|
|
|
|
|
-static void testHashCode(Core::Test& test) {
|
|
|
+static void testHashCode() {
|
|
|
String s;
|
|
|
- test.checkFalse(s.append("a"), "hash code 1");
|
|
|
- test.checkFalse(s.append("bc"), "hash code 2");
|
|
|
- test.checkFalse(s.append(20), "hash code 3");
|
|
|
- test.checkFalse(s.append(25.5f), "hash code 4");
|
|
|
- test.checkFalse(s.append(true), "hash code 5");
|
|
|
- test.checkEqual(build(test, "abc2025.50true").hashCode(), s.hashCode(),
|
|
|
- "string modification recalculates hash 1");
|
|
|
+ CORE_TEST_FALSE(s.append("a"));
|
|
|
+ CORE_TEST_FALSE(s.append("bc"));
|
|
|
+ CORE_TEST_FALSE(s.append(20));
|
|
|
+ CORE_TEST_FALSE(s.append(25.5f));
|
|
|
+ CORE_TEST_FALSE(s.append(true));
|
|
|
+ CORE_TEST_EQUAL(build("abc2025.50true").hashCode(), s.hashCode());
|
|
|
s.clear();
|
|
|
- test.checkEqual(String().hashCode(), s.hashCode(),
|
|
|
- "string modification recalculates hash 2");
|
|
|
+ CORE_TEST_EQUAL(String().hashCode(), s.hashCode());
|
|
|
}
|
|
|
|
|
|
-static void testAddSelf(Core::Test& test) {
|
|
|
+static void testAddSelf() {
|
|
|
String s;
|
|
|
- test.checkFalse(s.append("test1"), "add self 1");
|
|
|
- test.checkFalse(s.append(s), "add self 2");
|
|
|
- test.checkFalse(s.append(s), "add self 3");
|
|
|
- test.checkEqual(build(test, "test1test1test1test1"), s, "add self 4");
|
|
|
+ CORE_TEST_FALSE(s.append("test1"));
|
|
|
+ CORE_TEST_FALSE(s.append(s));
|
|
|
+ CORE_TEST_FALSE(s.append(s));
|
|
|
+ CORE_TEST_EQUAL(build("test1test1test1test1"), s);
|
|
|
}
|
|
|
|
|
|
-static void testAsHashMapKey(Core::Test& test) {
|
|
|
+static void testAsHashMapKey() {
|
|
|
Core::HashMap<String, int> map;
|
|
|
- test.checkFalse(map.add(build(test, "wusi"), 3), "as hashmap key 1");
|
|
|
- test.checkFalse(map.add(build(test, "hiThere"), 7), "as hashmap key 2");
|
|
|
- test.checkFalse(map.add(build(test, "baum123"), 5), "as hashmap key 3");
|
|
|
+ CORE_TEST_NOT_NULL(map.add(build("wusi"), 3));
|
|
|
+ CORE_TEST_NOT_NULL(map.add(build("hiThere"), 7));
|
|
|
+ CORE_TEST_NOT_NULL(map.add(build("baum123"), 5));
|
|
|
|
|
|
- int* a = map.search(build(test, "wusi"));
|
|
|
- int* b = map.search(build(test, "hiThere"));
|
|
|
- int* c = map.search(build(test, "baum123"));
|
|
|
- int* d = map.search(build(test, "423hifd"));
|
|
|
+ int* a = map.search(build("wusi"));
|
|
|
+ int* b = map.search(build("hiThere"));
|
|
|
+ int* c = map.search(build("baum123"));
|
|
|
+ int* d = map.search(build("423hifd"));
|
|
|
|
|
|
- test.checkTrue(a != nullptr, "strings works as hash key 1");
|
|
|
- test.checkTrue(b != nullptr, "strings works as hash key 2");
|
|
|
- test.checkTrue(c != nullptr, "strings works as hash key 3");
|
|
|
- test.checkTrue(d == nullptr, "strings works as hash key 4");
|
|
|
+ CORE_TEST_NOT_NULL(a);
|
|
|
+ CORE_TEST_NOT_NULL(b);
|
|
|
+ CORE_TEST_NOT_NULL(c);
|
|
|
+ CORE_TEST_NULL(d);
|
|
|
|
|
|
if(a != nullptr && b != nullptr && c != nullptr) {
|
|
|
- test.checkEqual(3, *a, "strings works as hash key 1");
|
|
|
- test.checkEqual(7, *b, "strings works as hash key 2");
|
|
|
- test.checkEqual(5, *c, "strings works as hash key 3");
|
|
|
+ CORE_TEST_EQUAL(3, *a);
|
|
|
+ CORE_TEST_EQUAL(7, *b);
|
|
|
+ CORE_TEST_EQUAL(5, *c);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void Core::ArrayStringTests::test() {
|
|
|
- Core::Test test("String");
|
|
|
- testEquality(test);
|
|
|
- testUnicodeEquality(test);
|
|
|
- testInequality(test);
|
|
|
- testStringAppend(test);
|
|
|
- testStringAppendOverflow(test);
|
|
|
- testCharacters(test);
|
|
|
- testLength(test);
|
|
|
- testChar(test);
|
|
|
- testSignedChar(test);
|
|
|
- testUnsignedChar(test);
|
|
|
- testSignedShort(test);
|
|
|
- testUnsignedShort(test);
|
|
|
- testSignedInt(test);
|
|
|
- testUnsignedInt(test);
|
|
|
- testSignedLong(test);
|
|
|
- testUnsignedLong(test);
|
|
|
- testSignedLongLong(test);
|
|
|
- testUnsignedLongLong(test);
|
|
|
- testFloat(test);
|
|
|
- testDouble(test);
|
|
|
- testLongDouble(test);
|
|
|
- testBool(test);
|
|
|
- testIntOverflow(test);
|
|
|
- testUnicode(test);
|
|
|
- testClear(test);
|
|
|
- testHashCode(test);
|
|
|
- testAddSelf(test);
|
|
|
- testAsHashMapKey(test);
|
|
|
- test.finalize();
|
|
|
+ testEquality();
|
|
|
+ testUnicodeEquality();
|
|
|
+ testInequality();
|
|
|
+ testStringAppend();
|
|
|
+ testStringAppendOverflow();
|
|
|
+ testCharacters();
|
|
|
+ testLength();
|
|
|
+ testChar();
|
|
|
+ testSignedChar();
|
|
|
+ testUnsignedChar();
|
|
|
+ testSignedShort();
|
|
|
+ testUnsignedShort();
|
|
|
+ testSignedInt();
|
|
|
+ testUnsignedInt();
|
|
|
+ testSignedLong();
|
|
|
+ testUnsignedLong();
|
|
|
+ testSignedLongLong();
|
|
|
+ testUnsignedLongLong();
|
|
|
+ testFloat();
|
|
|
+ testDouble();
|
|
|
+ testLongDouble();
|
|
|
+ testBool();
|
|
|
+ testIntOverflow();
|
|
|
+ testUnicode();
|
|
|
+ testClear();
|
|
|
+ testHashCode();
|
|
|
+ testAddSelf();
|
|
|
+ testAsHashMapKey();
|
|
|
}
|