public void When_testing_special_cases()
        {
            GenericAccessor <SpecialCase> accessor = Accessor.Build <SpecialCase>();

            accessor.ShouldBeOfType <GenericAccessor <SpecialCase> >();
            accessor.Type.ShouldBe(typeof(SpecialCase));
            accessor.IgnoreCase.ShouldBe(false);
            accessor.Properties.Count.ShouldBe(2);
            accessor.Properties.ShouldContain(x => x.Key == "GetterOnly");
            accessor.Properties.ShouldContain(x => x.Key == "SetterOnly");

            var instance = new SpecialCase();

            Should.Throw <ArgumentException>(() => { var _ = accessor[instance, "SetterOnly"]; })
            .Message.ShouldBe("Type: `Easy.Common.Tests.Unit.Accessors.GenericAccessorTests+SpecialCase` does not have a property named: `SetterOnly` that supports reading.");

            Should.Throw <ArgumentException>(() => accessor[instance, "GetterOnly"] = "bar")
            .Message.ShouldBe("Type: `Easy.Common.Tests.Unit.Accessors.GenericAccessorTests+SpecialCase` does not have a property named: `GetterOnly` that supports writing.");

            accessor.TrySet(instance, "GetterOnly", (object)"Baz").ShouldBeFalse();

            accessor.TryGet(instance, "SetterOnly", out object tmpResult1).ShouldBeFalse();
            tmpResult1.ShouldBeNull();

            accessor.TryGet(instance, "SetterOnly", out string tmpResult2).ShouldBeFalse();
            tmpResult2.ShouldBeNull();

            accessor.TrySet(instance, "GetterOnly", "Boo").ShouldBeFalse();

            accessor[instance, "SetterOnly"] = "Foo";
            accessor[instance, "GetterOnly"].ShouldBe("Foo");

            accessor.TrySet(instance, "SetterOnly", "Baz").ShouldBeTrue();

            accessor.TryGet(instance, "GetterOnly", out string result1).ShouldBeTrue();
            result1.ShouldBe("Baz");

            accessor.TrySet(instance, "SetterOnly", "Boo");

            accessor.TryGet(instance, "GetterOnly", out string result2).ShouldBeTrue();
            result2.ShouldBe("Boo");
        }
        public void When_testing_public_members()
        {
            GenericAccessor <Parent> accessor = Accessor.Build <Parent>();

            accessor.ShouldBeOfType <GenericAccessor <Parent> >();
            accessor.Type.ShouldBe(typeof(Parent));
            accessor.IgnoreCase.ShouldBe(false);
            accessor.IncludesNonPublic.ShouldBe(false);

            accessor.Properties.ShouldNotBeNull();
            accessor.Properties.Count.ShouldBe(2);

            var instance = new Parent();

            accessor[instance, "Name"] = "John";
            instance.Name.ShouldBe("John");

            accessor.TryGet <string>(instance, "Name", out string result1).ShouldBeTrue();
            result1.ShouldBe("John");

            accessor.TrySet(instance, "Age", (object)10).ShouldBeFalse();
            accessor.TrySet(instance, "Age", 10).ShouldBeTrue();

            accessor.TryGet(instance, "Age", out int result2).ShouldBeTrue();
            result2.ShouldBe(10);

            accessor.TrySet(instance, "Name", "Bobby").ShouldBeTrue();
            accessor[instance, "Name"].ShouldBe("Bobby");
            accessor.TryGet(instance, "Name", out string result3).ShouldBeTrue();
            result3.ShouldBe("Bobby");

            accessor.TrySet(instance, "Name", "Joey").ShouldBeTrue();
            accessor[instance, "Name"].ShouldBe("Joey");
            accessor.TryGet(instance, "Name", out string result4).ShouldBeTrue();
            result4.ShouldBe("Joey");

            accessor.TryGet(instance, "Name", out string result5).ShouldBeTrue();
            result5.ShouldBe("Joey");
        }