public void ShouldSetKeyPrefixAndSuffixWithinOutput()
{
var factory = DictionaryFormat
.CreateDefault()
.SetKeyPrefixAndSuffix("[", "]");
var toString = factory.Compile <int, string>();
Assert.That(factory.KeyPrefixAndSuffix, Is.EqualTo(("[", "]")));
Assert.That(toString(Dictionary), Is.EqualTo("{[0]:'null', [1]:'Leroy Jenkins', [7]:'James Bond'}"));
}
public void ShouldSetValuePrefixAndSuffixWithinOutput()
{
var factory = DictionaryFormat
.CreateDefault()
.SetValuePrefixAndSuffix("(", ")");
var toString = factory.Compile <int, string>();
Assert.That(factory.ValuePrefixAndSuffix, Is.EqualTo(("(", ")")));
Assert.That(toString(Dictionary), Is.EqualTo("{0:(null), 1:(Leroy Jenkins), 7:(James Bond)}"));
}
public void ShouldIncludeDictionaryPrefixAndSuffixIntoOutput()
{
var factory = DictionaryFormat
.CreateDefault()
.SetDictionaryPrefixAndSuffix("<", ">");
var toString = factory.Compile <int, string>();
Assert.That(factory.DictionaryPrefixAndSuffix, Is.EqualTo(("<", ">")));
Assert.That(toString(Dictionary), Is.EqualTo("<0:'null', 1:'Leroy Jenkins', 7:'James Bond'>"));
}
public void ShouldSetKeyValuePairSeparatorWithinOutput()
{
var factory = DictionaryFormat
.CreateDefault()
.SetKeyValuePairSeparator("|");
var toString = factory.Compile <int, string>();
Assert.That(factory.KeyValuePairSeparator, Is.EqualTo("|"));
Assert.That(toString(Dictionary), Is.EqualTo("{0:'null'|1:'Leroy Jenkins'|7:'James Bond'}"));
}
public void ShouldSetKeyValuePairPrefixAndSuffixWithinOutput()
{
var factory = DictionaryFormat
.CreateDefault()
.SetKeyValuePrefixAndSuffix("<", ">");
var toString = factory.Compile <int, string>();
Assert.That(factory.KeyValuePairPrefixAndSuffix, Is.EqualTo(("<", ">")));
Assert.That(toString(Dictionary), Is.EqualTo("{<0:'null'>, <1:'Leroy Jenkins'>, <7:'James Bond'>}"));
}
public void ShouldRemovePreviouslyAddedOption()
{
var factory = DictionaryFormat
.CreateDefault()
.AddOptions(DictionaryFormatOptions.ItemPerLine)
.RemoveOptions(DictionaryFormatOptions.ItemPerLine);
var toString = factory.Compile <int, string>();
Assert.That(factory.Options, Is.EqualTo(DictionaryFormatOptions.None));
Assert.That(toString(Dictionary), Is.EqualTo("{0:'null', 1:'Leroy Jenkins', 7:'James Bond'}"));
}
public void ShouldApplyNonGenericFunctionToGenericDictionary()
{
var toString = DictionaryFormat.CreateDefault().Compile();
Assert.That(
toString(new Dictionary <int, string>
{
{ 7, "James Bond" },
{ 8, "Bill Timothy" },
{ 12, "Sam Johnston" }
}),
Is.EqualTo("{7:'James Bond', 8:'Bill Timothy', 12:'Sam Johnston'}")
);
}
public void ShouldApplyFormatToOldDictionary()
{
var toString = DictionaryFormat.CreateDefault().Compile();
Assert.That(
toString(new Hashtable
{
{ 7, "James Bond" },
{ 8, "Bill Timothy" },
{ 12, "Sam Johnston" }
}),
Is.EqualTo("{12:'Sam Johnston', 8:'Bill Timothy', 7:'James Bond'}")
);
}
public void ShouldCreateDefaultFormat()
{
ValueTuple <string, string> emptyPrefixAndSuffix = (null, null);
var factory = DictionaryFormat.CreateDefault();
var toString = factory.Compile <int, string>();
Assert.That(factory.KeyValueSeparator, Is.EqualTo(":"));
Assert.That(factory.KeyValuePairSeparator, Is.EqualTo(", "));
Assert.That(factory.KeyPrefixAndSuffix, Is.EqualTo(emptyPrefixAndSuffix));
Assert.That(factory.ValuePrefixAndSuffix, Is.EqualTo(("'", "'")));
Assert.That(factory.KeyValuePairPrefixAndSuffix, Is.EqualTo(emptyPrefixAndSuffix));
Assert.That(factory.DictionaryPrefixAndSuffix, Is.EqualTo(("{", "}")));
Assert.That(factory.Options, Is.EqualTo(DictionaryFormatOptions.None));
Assert.That(toString(Dictionary), Is.EqualTo("{0:'null', 1:'Leroy Jenkins', 7:'James Bond'}"));
}
public void ShouldAlwaysCreateNewInstanceOfDefaultFormat()
{
var firstFormat = DictionaryFormat.CreateDefault()
.AddOptions(DictionaryFormatOptions.ItemPerLine)
.SetKeyPrefixAndSuffix("[", "]")
.SetKeyValuePrefixAndSuffix("<", ">");
var firstToString = firstFormat.Compile <int, string>();
var secondFormat = DictionaryFormat.CreateDefault();
var secondToString = secondFormat.Compile <int, string>();
Assert.That(secondFormat, Is.Not.SameAs(firstFormat));
Assert.That(secondToString, Is.Not.SameAs(firstToString));
Assert.That(
secondToString(Dictionary),
Is.EqualTo("{0:'null', 1:'Leroy Jenkins', 7:'James Bond'}")
);
}
public void ShouldProduceNewLineSeparatedOutputWithLineBreak()
{
var factory = DictionaryFormat
.CreateDefault()
.SetKeyValuePairSeparator(null)
.AddOptions(DictionaryFormatOptions.ItemPerLine);
var toString = factory.Compile <int, string>();
Assert.That(factory.Options, Is.EqualTo(DictionaryFormatOptions.ItemPerLine));
Assert.That(toString(Dictionary), Is.EqualTo(
new StringBuilder()
.AppendLine("{")
.AppendLine("0:'null'")
.AppendLine("1:'Leroy Jenkins'")
.AppendLine("7:'James Bond'")
.Append("}")
.ToString()
));
}
/// <summary>
/// Use <see cref="DictionaryFormat"/> for converting members of <see cref="IDictionary"/> type
/// to string. Only affects members which declared types are assignable to <see cref="IDictionary"/>.
/// </summary>
/// <param name="setup">
/// Function accepting default <see cref="DictionaryFormat"/> and returning modified version or brand new
/// instance to be used by <see cref="object.ToString"/> function being built. When it returns null than
/// default <see cref="DictionaryFormat"/> (the one passed to it) will be used.
/// <see cref="DictionaryFormat.CreateDefault"/> will be used when function is omitted (or null passed).
/// </param>
/// <returns>Updated <see cref="ToStringBuilder{TTarget}"/> instance.</returns>
public ToStringBuilder <TTarget> UseDictionaryFormat(
Func <DictionaryFormat, DictionaryFormat> setup = null
)
{
return(Use(SetupFormat(DictionaryFormat.CreateDefault(), setup).Compile()));
}
