feat:

+ tests swap expected and actual
+ test ToString(Span<char>)

+ Add method GetIndex
+ Add method Insert

Author: SoftStoneDevelop

Src/StringBuilderArray.Tests/AppendArrayFixture.cs

@@ -0,0 +1,90 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StringBuilderArrayTests
+{
+    [TestFixture]
+    public class AppendArrayFixture
+    {
+        public static object[] LengthCases = { 5, 7, 10, 50, 100, 1000, 2500 };
+
+        [Test]
+        [TestCaseSource(nameof(LengthCases))]
+        public void AppendArrayTest(int length)
+        {
+            var strBuilded = new string('a', length - 1);
+            var sb = new StringBuilder();
+            var list = new List<string>();
+            for (int i = 0; i < 53; i++)
+            {
+                var text = i.ToString() + strBuilded;
+                list.Add(text);
+                sb.Append(text);
+            }
+
+            var sbArr = new StringBuilderArray.StringBuilderArray();
+            sbArr.Append(list);
+
+            Assert.That(sb.ToString(), Is.EqualTo(sbArr.ToString()));
+#if NET5_0_OR_GREATER
+            var expectSpan = sb.ToString().AsSpan();
+            var resultSpan = GC.AllocateUninitializedArray<char>(sbArr.Length);
+            sbArr.ToString(resultSpan);
+            for (int i = 0; i < expectSpan.Length; i++)
+            {
+                var expectChar = expectSpan[i];
+                var haveChar = resultSpan[i];
+                Assert.That(haveChar, Is.EqualTo(expectChar));
+            }
+#endif
+
+            var index = 0;
+            foreach (var str in sbArr)
+            {
+                Assert.That(str, Is.EqualTo(list[index++]));
+            }
+        }
+
+        [Test]
+        [TestCaseSource(nameof(LengthCases))]
+        public void AppendLineArrayTest(int length)
+        {
+            var strBuilded = new string('a', length - 1);
+            var sb = new StringBuilder();
+            var list = new List<string>();
+            var listInput = new List<string>();
+            for (int i = 0; i < 53; i++)
+            {
+                var text = i.ToString() + strBuilded;
+                listInput.Add(text);
+                list.Add(text);
+                list.Add(Environment.NewLine);
+                sb.AppendLine(text);
+            }
+
+            var sbArr = new StringBuilderArray.StringBuilderArray();
+            sbArr.AppendLine(listInput);
+
+            Assert.That(sb.ToString(), Is.EqualTo(sbArr.ToString()));
+#if NET5_0_OR_GREATER
+            var expectSpan = sb.ToString().AsSpan();
+            var resultSpan = GC.AllocateUninitializedArray<char>(sbArr.Length);
+            sbArr.ToString(resultSpan);
+            for (int i = 0; i < expectSpan.Length; i++)
+            {
+                var expectChar = expectSpan[i];
+                var haveChar = resultSpan[i];
+                Assert.That(haveChar, Is.EqualTo(expectChar));
+            }
+#endif
+
+            var index = 0;
+            foreach (var str in sbArr)
+            {
+                Assert.That(str, Is.EqualTo(list[index++]));
+            }
+        }
+    }
+}

Src/StringBuilderArray.Tests/AppendFixture.cs

@@ -0,0 +1,105 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StringBuilderArrayTests
+{
+    [TestFixture]
+    public class AppendFixture
+    {
+        public static object[] LengthCases = { 5, 7, 10, 50, 100, 1000, 2500 };
+
+        [Test]
+        [TestCaseSource(nameof(LengthCases))]
+        public void AppendTest(int length)
+        {
+            var strBuilded = new string('a', length - 1);
+            var sb = new StringBuilder();
+            for (int i = 0; i < 53; i++)
+            {
+                sb.Append(i.ToString() + strBuilded);
+            }
+
+            var sbArr = new StringBuilderArray.StringBuilderArray();
+            for (int i = 0; i < 53; i++)
+            {
+                sbArr.Append(i.ToString() + strBuilded);
+            }
+
+#if NET5_0_OR_GREATER
+            var expectSpan = sb.ToString().AsSpan();
+            var resultSpan = GC.AllocateUninitializedArray<char>(sbArr.Length);
+            sbArr.ToString(resultSpan);
+            for (int i = 0; i < expectSpan.Length; i++)
+            {
+                var expectChar = expectSpan[i];
+                var haveChar = resultSpan[i];
+                Assert.That(haveChar, Is.EqualTo(expectChar));
+            }
+#endif
+            Assert.That(sbArr.ToString(), Is.EqualTo(sb.ToString()));
+        }
+
+        [Test]
+        [TestCaseSource(nameof(LengthCases))]
+        public void AppendClearTest(int length)
+        {
+            var strBuilded = new string('a', length - 1);
+            var sb = new StringBuilder();
+            for (int i = 53; i < 70; i++)
+            {
+                sb.Append(i.ToString() + strBuilded);
+            }
+
+            var sbArr = new StringBuilderArray.StringBuilderArray();
+            for (int i = 0; i < 53; i++)
+            {
+                sbArr.Append(i.ToString() + strBuilded);
+            }
+            sbArr.Clear();
+            for (int i = 53; i < 70; i++)
+            {
+                sbArr.Append(i.ToString() + strBuilded);
+            }
+
+#if NET5_0_OR_GREATER
+            var expectSpan = sb.ToString().AsSpan();
+            var resultSpan = GC.AllocateUninitializedArray<char>(sbArr.Length);
+            sbArr.ToString(resultSpan);
+            for (int i = 0; i < expectSpan.Length; i++)
+            {
+                var expectChar = expectSpan[i];
+                var haveChar = resultSpan[i];
+                Assert.That(haveChar, Is.EqualTo(expectChar));
+            }
+#endif
+            Assert.That(sbArr.ToString(), Is.EqualTo(sb.ToString()));
+        }
+
+        [Test]
+        [TestCaseSource(nameof(LengthCases))]
+        public void AppendEnumerableTest(int length)
+        {
+            var strBuilded = new string('a', length - 1);
+            var list = new List<string>();
+            for (int i = 0; i < 53; i++)
+            {
+                var text = i.ToString() + strBuilded;
+                list.Add(text);
+            }
+
+            var sbArr = new StringBuilderArray.StringBuilderArray();
+            for (int i = 0; i < 53; i++)
+            {
+                sbArr.Append(i.ToString() + strBuilded);
+            }
+
+            var index = 0;
+            foreach (var str in sbArr)
+            {
+                Assert.That(str, Is.EqualTo(list[index++]));
+            }
+        }
+    }
+}

Src/StringBuilderArray.Tests/AppendLineFixture.cs

@@ -0,0 +1,106 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StringBuilderArrayTests
+{
+    [TestFixture]
+    public class AppendLineFixture
+    {
+        public static object[] LengthCases = { 5, 7, 10, 50, 100, 1000, 2500 };
+
+        [Test]
+        [TestCaseSource(nameof(LengthCases))]
+        public void AppendLineTest(int length)
+        {
+            var strBuilded = new string('a', length - 1);
+            var sb = new StringBuilder();
+            for (int i = 0; i < 53; i++)
+            {
+                sb.AppendLine(i.ToString() + strBuilded);
+            }
+
+            var sbArr = new StringBuilderArray.StringBuilderArray();
+            for (int i = 0; i < 53; i++)
+            {
+                sbArr.AppendLine(i.ToString() + strBuilded);
+            }
+
+#if NET5_0_OR_GREATER
+            var expectSpan = sb.ToString().AsSpan();
+            var resultSpan = GC.AllocateUninitializedArray<char>(sbArr.Length);
+            sbArr.ToString(resultSpan);
+            for (int i = 0; i < expectSpan.Length; i++)
+            {
+                var expectChar = expectSpan[i];
+                var haveChar = resultSpan[i];
+                Assert.That(haveChar, Is.EqualTo(expectChar));
+            }
+#endif
+            Assert.That(sbArr.ToString(), Is.EqualTo(sb.ToString()));
+        }
+
+        [Test]
+        [TestCaseSource(nameof(LengthCases))]
+        public void AppendLineClearTest(int length)
+        {
+            var strBuilded = new string('a', length - 1);
+            var sb = new StringBuilder();
+            for (int i = 53; i < 70; i++)
+            {
+                sb.AppendLine(i.ToString() + strBuilded);
+            }
+
+            var sbArr = new StringBuilderArray.StringBuilderArray();
+            for (int i = 0; i < 53; i++)
+            {
+                sbArr.AppendLine(i.ToString() + strBuilded);
+            }
+            sbArr.Clear();
+            for (int i = 53; i < 70; i++)
+            {
+                sbArr.AppendLine(i.ToString() + strBuilded);
+            }
+
+#if NET5_0_OR_GREATER
+            var expectSpan = sb.ToString().AsSpan();
+            var resultSpan = GC.AllocateUninitializedArray<char>(sbArr.Length);
+            sbArr.ToString(resultSpan);
+            for (int i = 0; i < expectSpan.Length; i++)
+            {
+                var expectChar = expectSpan[i];
+                var haveChar = resultSpan[i];
+                Assert.That(haveChar, Is.EqualTo(expectChar));
+            }
+#endif
+            Assert.That(sbArr.ToString(), Is.EqualTo(sb.ToString()));
+        }
+
+        [Test]
+        [TestCaseSource(nameof(LengthCases))]
+        public void AppendLineEnumerableTest(int length)
+        {
+            var strBuilded = new string('a', length - 1);
+            var list = new List<string>();
+            for (int i = 0; i < 53; i++)
+            {
+                var text = i.ToString() + strBuilded;
+                list.Add(text);
+                list.Add(Environment.NewLine);
+            }
+
+            var sbArr = new StringBuilderArray.StringBuilderArray();
+            for (int i = 0; i < 53; i++)
+            {
+                sbArr.AppendLine(i.ToString() + strBuilded);
+            }
+
+            var index = 0;
+            foreach (var str in sbArr)
+            {
+                Assert.That(str, Is.EqualTo(list[index++]));
+            }
+        }
+    }
+}

Src/StringBuilderArray.Tests/GetIndexFixture.cs

@@ -0,0 +1,83 @@
+using NUnit.Framework;
+using System.Collections.Generic;
+
+namespace StringBuilderArrayTests
+{
+    [TestFixture]
+    public class GetIndexFixture
+    {
+        [Test]
+        public void GetIndex()
+        {
+            var sbArr = new StringBuilderArray.StringBuilderArray();
+            for (int i = 0; i < 10; i++)
+            {
+                sbArr.Append(i.ToString());
+                Assert.That(sbArr.GetIndex(i.ToString()), Is.EqualTo(0));
+            }
+
+            var index = 0;
+            for (int i = 10 - 1; i >= 0; i--)
+            {
+                Assert.That(sbArr.GetIndex(i.ToString()), Is.EqualTo(index++));
+            }
+
+            Assert.That(sbArr.GetIndex("10"), Is.EqualTo(-1));
+        }
+
+        [Test]
+        public void Insert()
+        {
+            var expect = new List<string>()
+            {
+                "0", "1","2","3","4","5","6","7","8","9"
+            };//count 10
+
+            var sbArr = new StringBuilderArray.StringBuilderArray();
+            for (int i = 0; i < 10; i++)
+            {
+                sbArr.Append(i.ToString());
+            }
+
+            expect.Insert(expect.Count - 1, "Secret before end");
+            //count 11
+            sbArr.Insert(0, "Secret before end");
+
+            var index = 0;
+            foreach (var str in sbArr)
+            {
+                Assert.That(str, Is.EqualTo(expect[index++]));
+            }
+
+            expect.Insert(0, "Secret start");
+            //count 12
+            sbArr.Insert(10, "Secret start");
+
+            index = 0;
+            foreach (var str in sbArr)
+            {
+                Assert.That(str, Is.EqualTo(expect[index++]));
+            }
+
+            expect.Insert(1, "Secret index 1");
+            //count 13
+            sbArr.Insert(10, "Secret index 1");
+
+            index = 0;
+            foreach (var str in sbArr)
+            {
+                Assert.That(str, Is.EqualTo(expect[index++]));
+            }
+
+            expect.Insert(9, "Secret index 9");
+            //count 14
+            sbArr.Insert(3, "Secret index 9");
+
+            index = 0;
+            foreach (var str in sbArr)
+            {
+                Assert.That(str, Is.EqualTo(expect[index++]));
+            }
+        }
+    }
+}