public void GetParameterFormatter_should_honor_custom_formatters_then_explicit_then_formattable_then_general_then_ToString() { var config = new ValueFormattingConfiguration() .RegisterFrameworkDefaultGeneralFormatters() .RegisterExplicit(typeof(bool), new FormatAttribute(">{0}<")) .RegisterExplicit(typeof(int), new FormatAttribute("i{0}")) .RegisterExplicit(typeof(MyFormattable2), new FormatAttribute("my-explicit2")) .RegisterGeneral(new MyStructFormatter()); var parameter = ParameterInfoHelper.GetMethodParameter <object[]>(Step_with_custom_formatters); var formatter = GetMetadataProvider(config).GetParameterFormatter(parameter); var values = new object[] { null, // null 5, // explicit int true, // [FormatBoolean] overriding explicit bool 5.5, // general struct new MyClass(), // toString new MyFormattable1(), // [Format] new MyFormattable2(), // explicit formatter new MyFormattable3() // ISelfFormattable }; Assert.That(formatter(values), Is.EqualTo("#<null> | #i5 | #On | #s5.5 | #my-class | #my-custom-format1 | #my-explicit2 | #my3")); }
public void It_should_initialize_object_with_default_values() { var configuration = new ValueFormattingConfiguration(); Assert.That(configuration.GeneralFormatters, Is.Empty); Assert.That(configuration.ExplicitFormatters.Keys, Is.EquivalentTo(new[] { typeof(string) })); }
public void It_should_clear_all_general_formatters() { var configuration = new ValueFormattingConfiguration() .RegisterGeneral(Mock.Of <IConditionalValueFormatter>()) .ClearGeneral(); Assert.That(configuration.GeneralFormatters, Is.Empty); }
public void It_should_register_general_formatter() { var formatter1 = Mock.Of <IConditionalValueFormatter>(); var formatter2 = Mock.Of <IConditionalValueFormatter>(); var configuration = new ValueFormattingConfiguration() .RegisterGeneral(formatter1) .RegisterGeneral(formatter2); Assert.That(configuration.GeneralFormatters.ToArray(), Is.EqualTo(new[] { formatter1, formatter2 })); }
public void It_should_clear_all_explicit_formatters() { var configuration = new ValueFormattingConfiguration(); var defaultExplicitFormatters = configuration.ExplicitFormatters.ToArray(); configuration .RegisterExplicit(typeof(char), Mock.Of <IValueFormatter>()) .ClearExplicit(); Assert.That(configuration.ExplicitFormatters .Select(x => x.GetType()) .ToArray(), Is.EquivalentTo(defaultExplicitFormatters .Select(x => x.GetType()) .ToArray())); }
public void It_should_register_explicit_formatter_allowing_to_override_previous_ones() { var formatter1 = Mock.Of <IValueFormatter>(); var formatter2 = Mock.Of <IValueFormatter>(); var configuration = new ValueFormattingConfiguration() .RegisterExplicit(typeof(string), formatter1) .RegisterExplicit(typeof(int), formatter1) .RegisterExplicit(typeof(object), formatter1) .RegisterExplicit(typeof(object), formatter2); Assert.That( configuration.ExplicitFormatters.ToDictionary(x => x.Key, x => x.Value), Is.EqualTo(new Dictionary <Type, IValueFormatter> { { typeof(string), formatter1 }, { typeof(int), formatter1 }, { typeof(object), formatter2 } })); }
private static TestMetadataProvider GetMetadataProvider(ValueFormattingConfiguration cfg) { return(new TestMetadataProvider(cfg)); }
public TestMetadataProvider(ValueFormattingConfiguration formattingConfiguration) : base(new DefaultNameFormatter(), new StepTypeConfiguration(), new DefaultCultureInfoProvider(), formattingConfiguration) { }
/// <summary> /// Constructor. /// </summary> /// <param name="nameFormatter"><see cref="INameFormatter"/> object used to format names.</param> /// <param name="stepTypeConfiguration"><see cref="StepTypeConfiguration"/> object used in providing step metadata.</param> /// <param name="cultureInfoProvider"><see cref="ICultureInfoProvider"/> object used in providing step parameter formatters.</param> /// <param name="valueFormattingConfiguration"><see cref="IValueFormattingService"/> object used to format parameters.</param> protected CoreMetadataProvider(INameFormatter nameFormatter, StepTypeConfiguration stepTypeConfiguration, ICultureInfoProvider cultureInfoProvider, ValueFormattingConfiguration valueFormattingConfiguration) { if (stepTypeConfiguration == null) { throw new ArgumentNullException(nameof(stepTypeConfiguration)); } _valueFormattingService = new ValueFormattingService(valueFormattingConfiguration, cultureInfoProvider); NameFormatter = nameFormatter ?? throw new ArgumentNullException(nameof(nameFormatter)); CultureInfoProvider = cultureInfoProvider ?? throw new ArgumentNullException(nameof(cultureInfoProvider)); _nameParser = new NameParser(nameFormatter); _stepTypeProcessor = new StepTypeProcessor(nameFormatter, stepTypeConfiguration); }
/// <summary> /// Applies framework default general formatters. /// </summary> /// <param name="configuration">Configuration.</param> /// <returns><paramref name="configuration"/>.</returns> public static ValueFormattingConfiguration RegisterFrameworkDefaultGeneralFormatters(this ValueFormattingConfiguration configuration) { return(configuration .RegisterGeneral(new DictionaryFormatter()) .RegisterGeneral(new CollectionFormatter())); }
public ValueFormattingService(ValueFormattingConfiguration configuration, ICultureInfoProvider cultureInfoProvider) { _generalFormatters = configuration.GeneralFormatters.ToArray(); _formatters = new ConcurrentDictionary <Type, IValueFormatter>(configuration.ExplicitFormatters); _cultureInfoProvider = cultureInfoProvider; }