public void ToTypeTest(MutableStringAppendTestType type)
{
if (type == MutableStringAppendTestType.Long)
{
MutableString s = new MutableString();
s.Assign((long)100000000000000000);
Assert.AreEqual(s.ToInt64(), (long)100000000000000000);
}
if (type == MutableStringAppendTestType.UTF8)
{
Array.Resize(ref utf8test, 100);
s.Assign("AAAaaa");
s.ToUTF8(utf8test);
for (int i = 0; i < 3; ++i)
{
Assert.AreEqual(utf8test[i], 65);
}
for (int i = 3; i < 6; ++i)
{
Assert.AreEqual(utf8test[i], 97);
}
utf8test[1] = 45;
utf8test[2] = 45;
s.ToUTF8(0, 2, utf8test, 0);
for (int i = 0; i < 2; ++i)
{
Assert.AreEqual(utf8test[i], 65);
}
Assert.AreEqual(utf8test[2], 45);
utf8test[1] = 45;
utf8test[2] = 45;
s.ToUTF8(utf8test, 2);
for (int i = 2; i < 5; ++i)
{
Assert.AreEqual(utf8test[i], 65);
}
for (int i = 5; i < 8; ++i)
{
Assert.AreEqual(utf8test[i], 97);
}
}
if (type == MutableStringAppendTestType.String)
{
MutableString s = new MutableString();
s.Assign("abacaba");
Assert.AreEqual(s.ToString(), "abacaba");
Assert.AreEqual(s.Count, 7);
}
}
public void TestInsert(MutableStringAppendTestType type)
{
MutableString s = new MutableString();
s.Append("abacaba");
if (type == MutableStringAppendTestType.ArrayOfChar)
{
s.Insert(3, ar);
Assert.AreEqual(s.ToString(), "abasswtuj1rcaba");
}
if (type == MutableStringAppendTestType.ArrayOfCharWithOffset)
{
s.Insert(3, ar, 2, 2);
Assert.AreEqual(s.ToString(), "abawtcaba");
}
if (type == MutableStringAppendTestType.MutableString)
{
MutableString b = new MutableString(ar);
s.Insert(3, b);
Assert.AreEqual(s.ToString(), "abasswtuj1rcaba");
}
if (type == MutableStringAppendTestType.String)
{
s.Insert(3, "111");
Assert.AreEqual(s.ToString(), "aba111caba");
Assert.AreEqual(new MutableString("2016-04-27 09:30:03.5927721").Insert(27, String.Empty), "2016-04-27 09:30:03.5927721");
Assert.AreEqual(new MutableString("2016-04-27 09:30:03.5927721").Insert(13, String.Empty), "2016-04-27 09:30:03.5927721");
Assert.AreEqual(new MutableString("aba").Insert(3, "aba"), "abaaba");
}
if (type == MutableStringAppendTestType.StringBuilder)
{
StringBuilder builder = new StringBuilder("111");
s.Insert(3, builder);
Assert.AreEqual(s.ToString(), "aba111caba");
}
if (type == MutableStringAppendTestType.Char)
{
s.Insert(3, 'c');
Assert.AreEqual(s.ToString(), "abaccaba");
}
if (type == MutableStringAppendTestType.CharPtr)
{
unsafe
{
fixed(char *ptr = ar)
{
s.Insert(3, ptr, 2);
Assert.AreEqual(s, "abasscaba");
}
}
}
if (type == MutableStringAppendTestType.Long)
{
Int64 number = 12345;
s.Insert(3, number);
Assert.AreEqual(s, "aba12345caba");
s = new MutableString("abacaba");
number = -12345;
s.Insert(3, number);
Assert.AreEqual(s, "aba-12345caba");
s = new MutableString("abacaba");
number = 0;
s.Insert(3, number);
Assert.AreEqual(s, "aba0caba");
}
}
public void MutableStringTestConstructors(MutableStringAppendTestType type)
{
if (type == MutableStringAppendTestType.MutableString)
{
MutableString s = new MutableString("ab");
MutableString s1 = new MutableString(s);
Assert.AreEqual(s, s1);
Assert.AreEqual(s1, "ab");
MutableString s2 = new MutableString(100, s);
Assert.AreEqual(s2, s);
Assert.AreEqual(s2.Capacity, 100);
}
if (type == MutableStringAppendTestType.String)
{
MutableString s = new MutableString("as");
Assert.AreEqual(s, "as");
s = new MutableString(105, "as");
Assert.AreEqual(s, "as");
Assert.AreEqual(s.Capacity, 105);
}
if (type == MutableStringAppendTestType.StringBuilder)
{
StringBuilder builder = new StringBuilder("abab");
MutableString s = new MutableString(builder);
Assert.AreEqual(s, "abab");
MutableString s1 = new MutableString(100, builder);
Assert.AreEqual(s1, "abab");
Assert.AreEqual(s1.Capacity, 100);
}
if (type == MutableStringAppendTestType.Char)
{
MutableString s = new MutableString('a');
Assert.AreEqual(s, "a");
MutableString s1 = new MutableString(256, 'a');
Assert.AreEqual(s1, "a");
Assert.AreEqual(256, s1.Capacity);
}
if (type == MutableStringAppendTestType.CharPtr)
{
unsafe
{
fixed(char *ptr = ar)
{
MutableString s = new MutableString(ptr, 8);
Assert.AreEqual(s, "sswtuj1r");
MutableString s1 = new MutableString(546, ptr, 8);
Assert.AreEqual(s1, "sswtuj1r");
Assert.AreEqual(s1.Capacity, 546);
}
}
}
if (type == MutableStringAppendTestType.ArrayOfChar)
{
MutableString s = new MutableString(ar);
Assert.AreEqual(s, "sswtuj1r");
MutableString s1 = new MutableString(100, ar);
Assert.AreEqual(s1, "sswtuj1r");
Assert.AreEqual(s1.Capacity, 100);
}
if (type == MutableStringAppendTestType.ArrayOfCharWithOffset)
{
MutableString s = new MutableString(ar, 1, 2);
Assert.AreEqual(s, "sw");
MutableString s1 = new MutableString(105, ar, 1, 2);
Assert.AreEqual(s1, "sw");
Assert.AreEqual(s1.Capacity, 105);
}
if (type == MutableStringAppendTestType.Integer)
{
s = new MutableString(100, -100);
Assert.AreEqual(s, "-100");
s = new MutableString(100, 100);
Assert.AreEqual(s, "100");
Assert.AreEqual(s.Capacity, 100);
}
if (type == MutableStringAppendTestType.Short)
{
s = new MutableString(100, (short)-100);
Assert.AreEqual(s, "-100");
s = new MutableString(100, (short)100);
Assert.AreEqual(s, "100");
Assert.AreEqual(s.Capacity, (short)100);
}
if (type == MutableStringAppendTestType.Long)
{
s = new MutableString(100, (long)-100);
Assert.AreEqual(s, "-100");
s = new MutableString(100, (long)100);
Assert.AreEqual(s, "100");
Assert.AreEqual(s.Capacity, (long)100);
}
}
public void TestAppend(MutableStringAppendTestType type)
{
if (type == MutableStringAppendTestType.Char)
{
s.Assign("sasd");
s.Append('e');
Assert.AreEqual(s, "sasde");
s.Assign('e');
Assert.AreEqual(s, "e");
s.Add('t');
Assert.AreEqual(s, "et");
}
if (type == MutableStringAppendTestType.String)
{
s.Assign("qwert");
s.Append("yuiop");
Assert.AreEqual(s, "qwertyuiop");
s.Assign("qwerty");
Assert.AreEqual(s, "qwerty");
}
if (type == MutableStringAppendTestType.Integer)
{
s.Assign("");
s.Append(-123);
Assert.AreEqual(s, "-123");
s.Assign("");
s.Append(124);
Assert.AreEqual(s, "124");
s.Assign(-123);
Assert.AreEqual(s, "-123");
s.Assign(124);
Assert.AreEqual(s, "124");
}
if (type == MutableStringAppendTestType.MutableString)
{
s.Assign("aba");
s1.Assign("caba");
s.Append(s1);
Assert.AreEqual(s, "abacaba");
s1.Append(s);
Assert.AreEqual(s1, "cabaabacaba");
s.Assign(s1);
Assert.AreEqual(s, "cabaabacaba");
}
if (type == MutableStringAppendTestType.ArrayOfChar)
{
s.Clear();
s.Append(ar);
Assert.AreEqual(s, "sswtuj1r");
s.Assign(ar);
Assert.AreEqual(s, "sswtuj1r");
}
if (type == MutableStringAppendTestType.ArrayOfCharWithOffset)
{
s.Clear();
s.Append(ar, 2, 4);
Assert.AreEqual(s, "wtuj");
s.Append(ar, 0, 1);
Assert.AreEqual(s, "wtujs");
s.Assign(ar, 2, 4);
Assert.AreEqual(s, "wtuj");
}
if (type == MutableStringAppendTestType.CharPtr)
{
unsafe
{
fixed(char *ptr = ar)
{
s.Clear();
s.Append(ptr, 5);
Assert.AreEqual(s, "sswtu");
s.Assign(ptr, 5);
Assert.AreEqual(s, "sswtu");
}
}
}
if (type == MutableStringAppendTestType.StringBuilder)
{
StringBuilder builder = new StringBuilder();
builder.Append("qazxcvb");
s.Clear();
s.Append(builder);
Assert.AreEqual(s, "qazxcvb");
s.Assign(builder);
Assert.AreEqual(s, "qazxcvb");
}
if (type == MutableStringAppendTestType.Long)
{
s.Assign("");
s.Append((long)-123);
Assert.AreEqual(s, "-123");
s.Assign("");
s.Append((long)124);
Assert.AreEqual(s, "124");
s.Assign((long)-123);
Assert.AreEqual(s, "-123");
s.Assign((long)124);
Assert.AreEqual(s, "124");
}
if (type == MutableStringAppendTestType.Short)
{
s.Assign("");
s.Append((short)-123);
Assert.AreEqual(s, "-123");
s.Assign("");
s.Append((short)124);
Assert.AreEqual(s, "124");
s.Assign((short)-123);
Assert.AreEqual(s, "-123");
s.Assign((short)124);
Assert.AreEqual(s, "124");
}
if (type == MutableStringAppendTestType.UTF8)
{
s.Clear();
s.AppendUTF8(utf8);
Assert.AreEqual(s, "AAAABa");
s.Clear();
s.AppendUTF8(utf8, 4, 2);
Assert.AreEqual(s, "Ba");
s.Clear();
unsafe
{
fixed(byte *ptr = utf8)
{
s.AppendUTF8(ptr, 6);
Assert.AreEqual(s, "AAAABa");
}
}
s.AssignUTF8(utf8);
Assert.AreEqual(s, "AAAABa");
s.AssignUTF8(utf8, 4, 2);
Assert.AreEqual(s, "Ba");
unsafe
{
fixed(byte *ptr = utf8)
{
s.AssignUTF8(ptr, 6);
Assert.AreEqual(s, "AAAABa");
}
}
}
if (type == MutableStringAppendTestType.UTF16)
{
String tempString = "abacaba";
utf16 = UnicodeEncoding.Unicode.GetBytes(tempString);
s.Clear();
s.AppendUTF16(utf16);
Assert.AreEqual(s, "abacaba");
s.Clear();
unsafe
{
fixed(byte *ptr = utf16)
{
s.AppendUTF16(ptr, 4);
Assert.AreEqual(s, "ab");
}
}
s.Clear();
s.AppendUTF16(utf16, 0, 4);
Assert.AreEqual(s, "ab");
s.AssignUTF16(utf16);
Assert.AreEqual(s, "abacaba");
unsafe
{
fixed(byte *ptr = utf16)
{
s.AssignUTF16(ptr, 4);
Assert.AreEqual(s, "ab");
}
}
s.AssignUTF16(utf16, 0, 4);
Assert.AreEqual(s, "ab");
}
if (type == MutableStringAppendTestType.UUID)
{
s.Clear();
s.Assign(uuid, UUIDPrintFormat.LowerCase);
s.Append(uuid, UUIDPrintFormat.LowerCase);
Assert.AreEqual("01234567-89ab-cdef-1011-12131415161701234567-89ab-cdef-1011-121314151617", s);
s.Clear();
s.Assign(uuid, UUIDPrintFormat.UpperCase);
s.Append(uuid, UUIDPrintFormat.UpperCase);
Assert.AreEqual("01234567-89AB-CDEF-1011-12131415161701234567-89AB-CDEF-1011-121314151617", s);
s.Clear();
s.Assign(uuid, UUIDPrintFormat.LowerCaseWithoutDashes);
s.Append(uuid, UUIDPrintFormat.LowerCaseWithoutDashes);
Assert.AreEqual("0123456789abcdef10111213141516170123456789abcdef1011121314151617", s);
s.Clear();
s.Assign(uuid, UUIDPrintFormat.UpperCaseWithoutDashes);
s.Append(uuid, UUIDPrintFormat.UpperCaseWithoutDashes);
Assert.AreEqual("0123456789ABCDEF10111213141516170123456789ABCDEF1011121314151617", s);
}
if (type == MutableStringAppendTestType.DateTime)
{
s.Clear();
DateTime dateTime = new DateTime(2016, 1, 1, 9, 7, 55, 555);
s.Append(dateTime);
Assert.AreEqual(s.ToString(), "01/01/2016 09:07:55.555");
dateTime = new DateTime(2016, 10, 11, 19, 17, 55, 555);
s.Assign(dateTime);
Assert.AreEqual(s.ToString(), "10/11/2016 19:17:55.555");
}
if (type == MutableStringAppendTestType.HdDateTime)
{
s.Clear();
HdDateTime dateTime = new HdDateTime(new DateTime(2016, 1, 1, 9, 7, 55, 555), 10);
s.Append(dateTime);
Assert.AreEqual(s.ToString(), "01/01/2016 09:07:55.555.10");
dateTime = new HdDateTime(new DateTime(2016, 10, 11, 19, 17, 55, 555), 9);
s.Assign(dateTime);
Assert.AreEqual(s.ToString(), "10/11/2016 19:17:55.555.09");
}
if (type == MutableStringAppendTestType.TimeSpan)
{
s.Clear();
TimeSpan timeSpan = new TimeSpan(10, 9, 7, 55, 555);
s.Append(timeSpan);
Assert.AreEqual(s.ToString(), "10.09:07:55.555");
timeSpan = new TimeSpan(9, 19, 17, 55, 55);
s.Assign(timeSpan);
Assert.AreEqual(s.ToString(), "9.19:17:55.055");
}
if (type == MutableStringAppendTestType.HdTimeSpan)
{
s.Clear();
HdTimeSpan timeSpan = new HdTimeSpan(new TimeSpan(10, 9, 7, 55, 555));
s.Append(timeSpan);
Assert.AreEqual(s.ToString(), "10.09:07:55.555.00");
timeSpan = new HdTimeSpan(new TimeSpan(9, 19, 17, 55, 55));
s.Assign(timeSpan);
Assert.AreEqual(s.ToString(), "9.19:17:55.055.00");
}
if (type == MutableStringAppendTestType.Double)
{
s.Clear();
s.Append((double)3.14);
Assert.AreEqual((s.ToString() == "3.14" || s.ToString() == "3,14"), true);
s.Assign((double)3.1459);
Assert.AreEqual((s.ToString() == "3.1459" || s.ToString() == "3,1459"), true);
}
if (type == MutableStringAppendTestType.Float)
{
s.Clear();
s.Append((float)3.14);
Assert.AreEqual((s.ToString() == "3.14" || s.ToString() == "3,14"), true);
s.Assign((float)3.1459);
Assert.AreEqual((s.ToString() == "3.1459" || s.ToString() == "3,1459"), true);
}
if (type == MutableStringAppendTestType.Boolean)
{
s.Clear();
s.Append(true);
Assert.AreEqual(s.ToString(), "True");
s.Assign(false);
Assert.AreEqual(s.ToString(), "False");
}
if (type == MutableStringAppendTestType.Decimal)
{
s.Clear();
s.Append((decimal)3.14);
Assert.AreEqual((s.ToString() == "3.14" || s.ToString() == "3,14"), true);
s.Assign((decimal)3.1459);
Assert.AreEqual((s.ToString() == "3.1459" || s.ToString() == "3,1459"), true);
}
if (type == MutableStringAppendTestType.Object)
{
s.Clear();
Tuple <int, int> tuple = new Tuple <int, int>(1, 1);
s.Append(tuple);
Assert.AreEqual(tuple.ToString(), s.ToString());
s.Assign(tuple);
Assert.AreEqual(tuple.ToString(), s.ToString());
}
}
