IronRuby.Tests.Tests.MutableString_Characters1 C# (CSharp) Method

        public void MutableString_Characters1() {
            TestChars(MS("αβ", RubyEncoding.UTF8), "αβ");
            TestChars(MS(Encoding.UTF8.GetBytes("αβ"), RubyEncoding.UTF8), "αβ");
            TestChars(MS("α", RubyEncoding.UTF8).Append('β'), "αβ");
            TestChars(MS(Encoding.UTF8.GetBytes("ab"), RubyEncoding.UTF8), "ab");
            TestChars(MS(Encoding.UTF8.GetBytes("ab"), RubyEncoding.Binary), "ab");

            var sjis = RubyEncoding.SJIS.StrictEncoding.GetBytes("あ");
            var beta = Encoding.UTF8.GetBytes("β");
            var x = new byte[] { (byte)'x' };
            var uinvalid = new byte[] { 0xff };
            var u12345 = new byte[] { 0xF0, 0x92, 0x8D, 0x85 }; // \u{12345} in UTF-8

            var c_sjis = new MSC('あ');
            var c_beta = new MSC('β');
            var c_x = new MSC('x');
            var c_uinvalid = new MSC(uinvalid);
            var s_u12345 = Encoding.UTF8.GetString(u12345);

            Assert(beta.Length == 2);

            // binary:
            TestChars(
                MutableString.CreateBinary(Utils.Concatenate(beta, x), RubyEncoding.Binary),
                new MSC((char)beta[0]), new MSC((char)beta[1]), new MSC('x') 
            );

            TestChars(
                MutableString.CreateBinary(Utils.Concatenate(beta, beta, x, x), RubyEncoding.UTF8),
                c_beta, c_beta, c_x, c_x
            );

            TestChars(
                MutableString.CreateBinary(Utils.Concatenate(beta, uinvalid, uinvalid, beta, x, x, uinvalid), RubyEncoding.UTF8),
                c_beta, c_uinvalid, c_uinvalid, c_beta, c_x, c_x, c_uinvalid
            );

            TestChars(
                MutableString.CreateBinary(Utils.Concatenate(u12345, beta), RubyEncoding.UTF8),
                new MSC(s_u12345[0], s_u12345[1]), c_beta
            );

            // string:
            TestChars(
                MutableString.CreateMutable("α" + s_u12345 + "xβ", RubyEncoding.UTF8),
                new MSC('α'), new MSC(s_u12345[0], s_u12345[1]), c_x, c_beta
            );

            TestChars(
                MutableString.CreateMutable(BinaryEncoding.Instance.GetString(Encoding.UTF8.GetBytes("xβ")), RubyEncoding.Binary),
                c_x, new MSC((char)beta[0]), new MSC((char)beta[1])
            );

            // chars:
            TestChars(
                MutableString.CreateMutable("α" + s_u12345 + "xβ", RubyEncoding.UTF8).Remove(4, 1),
                new MSC('α'), new MSC(s_u12345[0], s_u12345[1]), c_x
            );

            // remaining:
            TestChars(
                MutableString.CreateBinary(Utils.Concatenate(beta, uinvalid, uinvalid, beta, x, x, uinvalid), RubyEncoding.UTF8), 
                MutableString.CreateBinary(Utils.Concatenate(uinvalid, beta, x, x, uinvalid), RubyEncoding.UTF8),
                c_beta, c_uinvalid
            );

            TestChars(
                MutableString.CreateBinary(Utils.Concatenate(uinvalid, uinvalid, uinvalid), RubyEncoding.UTF8),
                MutableString.CreateBinary(uinvalid, RubyEncoding.UTF8),
                c_uinvalid, c_uinvalid
            );

            TestChars(
                MutableString.CreateBinary(uinvalid, RubyEncoding.UTF8),
                MutableString.CreateBinary(new byte[0], RubyEncoding.UTF8),
                c_uinvalid
            );

            TestChars(
                MutableString.CreateMutable("α" + s_u12345 + "xβ", RubyEncoding.UTF8),
                MutableString.CreateMutable("xβ", RubyEncoding.UTF8),
                new MSC('α'), new MSC(s_u12345[0], s_u12345[1])
            );

            TestChars(
                MutableString.CreateMutable("α" + s_u12345 + "xβ", RubyEncoding.UTF8).Remove(4, 1),
                MutableString.CreateMutable("x", RubyEncoding.UTF8),
                new MSC('α'), new MSC(s_u12345[0], s_u12345[1])
            );

            // all Unicode ecnodings
            foreach (var e in new[] { 
                RubyEncodingOps.UTF_16LE, RubyEncodingOps.UTF_16BE, 
                RubyEncodingOps.UTF_32LE, RubyEncodingOps.UTF_32BE,
                RubyEncodingOps.UTF_7, RubyEncodingOps.UTF_8 }) {

                TestChars(
                    MutableString.CreateMutable("α" + s_u12345 + "xβ", e),
                    new MSC('α'),
                    new MSC(s_u12345[0], s_u12345[1]),
                    new MSC('x'),
                    new MSC('β')
                );
            }
        }