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 Test001()
        {
            var member = new MemberReflection();
            var result = member.From(()=>default(string).Length);

            Assert.AreEqual(
                typeof(string).GetMember("Length").Single(),
                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 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));
        }