"Tests" that show FakeItEasy ArgumentValueFormatter behaviour and sort of a proposed interface to extend

PiggybackArgumentValueFormatter.cs

namespace FakeItEasyQuestions
{
    using FakeItEasy;
    using NUnit.Framework;

    public class ArgumentValueFormatterTests
    {
        public class NamedValue
        {
            public string Name;
            public object Value;
        }

        public class NamedValueWithArgumentFormatter
        {
            public string Name;
            public object Value;
        }

        public interface IFoo
        {
            void Foo2(string name, object value);
            void Foo(NamedValue namedValue);
            void Foo(NamedValueWithArgumentFormatter namedValue);
        }

        public class NameValueArgumentFormatter : ArgumentValueFormatter<NamedValueWithArgumentFormatter>
        {
            protected override string GetStringValue(NamedValueWithArgumentFormatter argumentValue)
            {
                return string.Format("NamedValueWithArgumentFormatter{{ Name: {0}, Value: {1} }}",
                                     argumentValue.Name, argumentValue.Value);
            }
        }

        [Test]
        public void How_fakeiteasy_renders_builtins()
        {
            var fakeFoo = A.Fake<IFoo>();

            fakeFoo.Foo2(null, "21.3");

            A.CallTo(fakeFoo).MustNotHaveHappened();
        }

        [Test]
        public void How_fakeiteasy_renders_named_values()
        {
            var fakeFoo = A.Fake<IFoo>();

            fakeFoo.Foo(new NamedValue {Name = "Blair", Value = "21.3"});

            A.CallTo(fakeFoo).MustNotHaveHappened();
        }

        [Test]
        public void How_a_naive_argument_formatter_renders_named_values()
        {
            var fakeFoo = A.Fake<IFoo>();

            fakeFoo.Foo(new NamedValueWithArgumentFormatter {Name = null, Value = "21.3"});

            A.CallTo(fakeFoo).MustNotHaveHappened();
        }

        [Test]
        public void How_the_new_argument_formatter_renders_named_values()
        {
            IObjectFormatter helperFormatter = new SimulatedFakeItEasyObjectFormatter();
            var formattedNameValue =
                new ProposedNameValueArgumentFormatter().GetStringValue(new NamedValue {Name = null, Value = "21.3"},
                                                                        helperFormatter);

            Assert.That(formattedNameValue,
                        Is.EqualTo(@"NamedValueWithArgumentFormatter{ Name: <NULL>, Value: ""21.3"" }"));
        }


        public interface IObjectFormatter
        {
            string GetStringValue(object value);
        }


        public class ProposedNameValueArgumentFormatter
            // would implement ArgumentValueFormatter<NamedValueWithArgumentFormatter>
        {
            public string GetStringValue(NamedValue argumentValue, IObjectFormatter helperFormatter)
            {
                return string.Format("NamedValueWithArgumentFormatter{{ Name: {0}, Value: {1} }}",
                                     helperFormatter.GetStringValue(argumentValue.Name),
                                     helperFormatter.GetStringValue(argumentValue.Value));
            }
        }


        public class SimulatedFakeItEasyObjectFormatter : IObjectFormatter
        {
            public string GetStringValue(object value)
            {
                // simulates FakeItEasy's builtin ArguumentValueFormatters. In real life, FakeItEasy
                // would delegate to any argument value formatters it could find.
                if (value == null)
                {
                    return "<NULL>";
                }

                var stringValue = value as string;
                if (stringValue != null)
                {
                    return '"' + stringValue + '"';
                }

                return value.ToString();
            }
        }
    }
}