public void Test001()
        {
            var member = new MemberReflection();
            var result = member.From(()=>default(string).Length);

            Assert.AreEqual(
                typeof(string).GetMember("Length").Single(),
                result);
        }
        public void Test005()
        {
            var member = new MemberReflection();
            var result = member.From(() => default(Dummy01)[default(string)]);

            Assert.AreEqual(
                typeof(Dummy01).GetProperty("Item", new Type[] { typeof(string) }),
                result);
        }
        public void Test002()
        {
            var member = new MemberReflection();
            var result = member.From(() => default(string)[0]);

            Assert.AreEqual(
                typeof(string).GetProperty("Chars"),
                result);
        }
        public void Test003()
        {
            try {
                var member = new MemberReflection();
                var result = member.From(() => default(string[])[0]);

                Assert.Fail("Expected an exception to be thrown");
            }
            catch (InvalidExpressionException eError) {
                // there is not indexer property for arrays
            }
        }
        public void Test006()
        {
            var member = new MemberReflection();
            // is there no way to generate an IndexExpression using a lambda?
            var result = member.From<string>(
                Expression.Lambda<Func<string>>(
                    Expression.MakeIndex(
                        Expression.Default(typeof(Dummy01)),
                        typeof(Dummy01).GetProperty("Item", new Type[] { typeof(int) }),
                        new Expression[] { Expression.Default(typeof(int)) }
                    )
                )
            );

            Assert.AreEqual(
                typeof(Dummy01).GetProperty("Item", new Type[] { typeof(int) }),
                result);
        }
        public void Test027()
        {
            var member = new MemberReflection();
            var mi = member.From(() => default(Dummy01)[default(string)]);
            var instance = new Dummy01();
            instance["DEF"] = "ABC";

            Assert.AreEqual(instance["DEF"], "ABC");

            member.SetValue(mi, instance, "GHI", "DEF");

            Assert.AreEqual(instance["DEF"], "GHI");
        }
        public void Test024()
        {
            var member = new MemberReflection();
            var mi = member.From(() => default(Dummy01)[default(int)]);
            var instance = new Dummy01();
            instance[1] = "ABC";

            Assert.AreEqual(member.GetValue(mi, instance, 1), "ABC");
        }
        public void Test023()
        {
            var member = new MemberReflection();
            var mi = member.From(() => default(Dummy02).MutableProperty);
            var instance = new Dummy02
            {
                MutableField = "ABC",
                MutableProperty = "DEF",
            };

            Assert.AreEqual(instance.MutableProperty, "DEF");
            member.SetValue(mi, instance, "GHI");
            Assert.AreEqual(instance.MutableProperty, "GHI");
        }
        public void Test011()
        {
            var member = new MemberReflection();
            var result = member.IsReadOnly(typeof(string).GetMethod("Trim", new Type[] { }));

            Assert.IsTrue(result);
        }
        public void Test017()
        {
            var member = new MemberReflection();
            var result = member.NameOf(() => default(Dummy01)[default(string)]);

            Assert.AreEqual("Item", result);
        }
        public void Test015()
        {
            var member = new MemberReflection();
            var result = member.NameOf(() => default(Dummy03).FieldOne);

            Assert.AreEqual("FieldOne", result);
        }
        public void Test014()
        {
            var member = new MemberReflection();
            var result = member.NameOf(() => default(Version).MajorRevision);

            Assert.AreEqual("MajorRevision", result);
        }
        public void Test013()
        {
            var member = new MemberReflection();
            var result = member.NameOf(()=>default(string).Length);

            Assert.AreEqual("Length", result);
        }
        public void Test012()
        {
            var member = new MemberReflection();
            var result = member.IsReadOnly(typeof(string).GetConstructors()[0]);

            Assert.IsTrue(result);
        }
        public void Test021()
        {
            var member = new MemberReflection();
            var mi = member.From(() => default(Dummy02).ReadonlyProperty);
            var instance = new Dummy02
            {
                MutableField = "ABC",
                MutableProperty = "DEF",
            };

            Assert.AreEqual(instance.ReadonlyProperty, member.GetValue<string>(mi, instance));
        }
        public void Test007()
        {
            var member = new MemberReflection();
            var result = member.IsReadOnly(typeof(Dummy02).GetMember("ReadonlyField")[0]);

            Assert.IsTrue(result);
        }
        public void Test010()
        {
            var member = new MemberReflection();
            var result = member.IsReadOnly(typeof(Dummy02).GetMember("MutableProperty")[0]);

            Assert.IsFalse(result);
        }