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

        public void MutableString_LastIndexOf1() {
           string s = "12123";

            var strs = new[] {
                MutableString.CreateBinary(Utils.Concatenate(BinaryEncoding.Instance.GetBytes(s), new byte[] { 0, 0 })).Remove(s.Length, 2),
                MutableString.CreateMutable(s + "α", RubyEncoding.UTF8),
                MutableString.CreateMutable(s, RubyEncoding.UTF8).Append('α'),
                MutableString.CreateMutable(s, RubyEncoding.Binary).Append(new byte[] { 0xff }),
            };

            for (int i = 0; i < strs.Length; i++) {
                var a = strs[i];

                a = MutableString.CreateBinary(Utils.Concatenate(BinaryEncoding.Instance.GetBytes(s), new byte[] { 0, 0 }));
                a.Remove(s.Length, 2);

                Action<string> test1 = (value) => {
                    Assert(a.LastIndexOf(BinaryEncoding.Instance.GetBytes(value)) == s.LastIndexOf(value));
                };

                Action<string, int> test2 = (value, start) => {
                    Assert(a.LastIndexOf(BinaryEncoding.Instance.GetBytes(value), start) == s.LastIndexOf(value, start));
                };

                Action<string, int, int> test3 = (value, start, count) => {
                    Assert(a.LastIndexOf(BinaryEncoding.Instance.GetBytes(value), start, count) == s.LastIndexOf(value, start, count));
                };

                test1("");
                test1("0");
                test1("12");
                test1("3");
                test2("12", 0);
                test2("12", 1);
                test2("12", 2);
                test3("12", 4, 2);
                test3("12", 4, 3);
                test3("12", 0, 1);
                test3("12", 0, 0);
                test3("", 2, 0);

                Assert(a.LastIndexOf('3', 9, 5) == (s + "-----").LastIndexOf('3', 9, 5));
                Assert(a.LastIndexOf('2', 2) == s.LastIndexOf('2', 2));
                Assert(a.LastIndexOf('\0') == -1);

                Assert(a.LastIndexOf((byte)'3', 9, 5) == (s + "-----").LastIndexOf('3', 9, 5));
                Assert(a.LastIndexOf((byte)'2', 2) == s.LastIndexOf('2', 2));
                Assert(a.LastIndexOf(0) == -1);

                Assert(a.LastIndexOf("123", 9, 5) == (s + "-----").LastIndexOf("123", 9, 5));
                Assert(a.LastIndexOf("123", 1) == s.LastIndexOf("123", 1));
            }

            AssertExceptionThrown<ArgumentNullException>(() => strs[0].LastIndexOf((byte[])null, 1, 2));
            AssertExceptionThrown<ArgumentNullException>(() => strs[0].LastIndexOf((string)null, 1, 2));
            AssertExceptionThrown<ArgumentException>(() => strs[0].LastIndexOf((byte)6, -1, 0));
            AssertExceptionThrown<ArgumentException>(() => strs[0].LastIndexOf((byte)6, 0, -1));
            AssertExceptionThrown<ArgumentException>(() => strs[0].LastIndexOf((byte)6, 1, 3));
            AssertExceptionThrown<ArgumentException>(() => strs[0].LastIndexOf('6', -1, 0));
            AssertExceptionThrown<ArgumentException>(() => strs[0].LastIndexOf('6', 0, -1));
            AssertExceptionThrown<ArgumentException>(() => strs[0].LastIndexOf(new byte[] { 6 }, -1, 0));
            AssertExceptionThrown<ArgumentException>(() => strs[0].LastIndexOf(new byte[] { 6 }, 0, -1));
            AssertExceptionThrown<ArgumentException>(() => strs[0].LastIndexOf("6", -1, 0));
            AssertExceptionThrown<ArgumentException>(() => strs[0].LastIndexOf("6", 0, -1));
        }