public void AppendFormatted_ValueTypes_CreateProviderFlowed(bool useScratch)
{
void Test <T>(T t)
{
var provider = new CultureInfo("en-US");
DefaultInterpolatedStringHandler handler = useScratch ?
new DefaultInterpolatedStringHandler(1, 2, provider, stackalloc char[16]) :
new DefaultInterpolatedStringHandler(1, 2, provider);
handler.AppendFormatted(t);
Assert.Same(provider, ((IHasToStringState)t).ToStringState.LastProvider);
handler.AppendFormatted(t, 1);
Assert.Same(provider, ((IHasToStringState)t).ToStringState.LastProvider);
handler.AppendFormatted(t, "X2");
Assert.Same(provider, ((IHasToStringState)t).ToStringState.LastProvider);
handler.AppendFormatted(t, 1, "X2");
Assert.Same(provider, ((IHasToStringState)t).ToStringState.LastProvider);
}
Test(new FormattableInt32Wrapper(42));
Test(new SpanFormattableInt32Wrapper(84));
Test((FormattableInt32Wrapper?)new FormattableInt32Wrapper(42));
Test((SpanFormattableInt32Wrapper?)new SpanFormattableInt32Wrapper(84));
}
public void AppendFormatted_String_ICustomFormatter()
{
var provider = new ConcatFormatter();
var expected = new StringBuilder();
DefaultInterpolatedStringHandler actual = new DefaultInterpolatedStringHandler(0, 0, provider);
foreach (string s in new[] { null, "", "a" })
{
// string
expected.AppendFormat(provider, "{0}", s);
actual.AppendFormatted(s);
// string, format
expected.AppendFormat(provider, "{0:X2}", s);
actual.AppendFormatted(s, "X2");
// string, alignment
expected.AppendFormat(provider, "{0,3}", s);
actual.AppendFormatted(s, 3);
// string, alignment, format
expected.AppendFormat(provider, "{0,-3:X2}", s);
actual.AppendFormatted(s, -3, "X2");
}
Assert.Equal(expected.ToString(), actual.ToStringAndClear());
}
public void AppendFormatted_ReadOnlySpanChar()
{
var expected = new StringBuilder();
DefaultInterpolatedStringHandler actual = new DefaultInterpolatedStringHandler(0, 0);
foreach (string s in new[] { "", "a", "bc", "def", "this is a longer string", "!" })
{
// span
expected.Append(s);
actual.AppendFormatted((ReadOnlySpan <char>)s);
// span, format
expected.AppendFormat("{0:X2}", s);
actual.AppendFormatted((ReadOnlySpan <char>)s, format: "X2");
foreach (int alignment in new[] { 0, 3, -3 })
{
// span, alignment
expected.AppendFormat("{0," + alignment.ToString(CultureInfo.InvariantCulture) + "}", s);
actual.AppendFormatted((ReadOnlySpan <char>)s, alignment);
// span, alignment, format
expected.AppendFormat("{0," + alignment.ToString(CultureInfo.InvariantCulture) + ":X2}", s);
actual.AppendFormatted((ReadOnlySpan <char>)s, alignment, "X2");
}
}
Assert.Equal(expected.ToString(), actual.ToStringAndClear());
}
private static void FormatArgument <T>(ref DefaultInterpolatedStringHandler builder, T arg, int?alignment, string?format)
{
if (arg is null)
{
builder.AppendLiteral(NullValue);
}
else
{
if (alignment.HasValue && format is not null)
{
builder.AppendFormatted <T>(arg, alignment.GetValueOrDefault(), format);
}
else if (alignment.HasValue)
{
builder.AppendFormatted <T>(arg, alignment.GetValueOrDefault());
}
else if (format is not null)
{
builder.AppendFormatted <T>(arg, format);
}
else
{
builder.AppendFormatted <T>(arg);
}
}
}
public void ToStringAndClear_Clears()
{
DefaultInterpolatedStringHandler handler = new DefaultInterpolatedStringHandler(0, 0);
handler.AppendLiteral("hi");
Assert.Equal("hi", handler.ToStringAndClear());
Assert.Equal(string.Empty, handler.ToStringAndClear());
}
public void AppendFormatted_ReferenceTypes()
{
var expected = new StringBuilder();
DefaultInterpolatedStringHandler actual = new DefaultInterpolatedStringHandler(0, 0);
foreach (string rawInput in new[] { null, "", "a", "bc", "def", "this is a longer string", "!" })
{
foreach (object o in new object[]
{
rawInput, // raw string directly; ToString will return itself
new StringWrapper(rawInput), // wrapper object that returns string from ToString
new FormattableStringWrapper(rawInput), // IFormattable wrapper around string
new SpanFormattableStringWrapper(rawInput) // ISpanFormattable wrapper around string
})
{
// object
expected.AppendFormat("{0}", o);
actual.AppendFormatted(o);
if (o is IHasToStringState tss1)
{
Assert.True(string.IsNullOrEmpty(tss1.ToStringState.LastFormat));
AssertModeMatchesType(tss1);
}
// object, format
expected.AppendFormat("{0:X2}", o);
actual.AppendFormatted(o, "X2");
if (o is IHasToStringState tss2)
{
Assert.Equal("X2", tss2.ToStringState.LastFormat);
AssertModeMatchesType(tss2);
}
foreach (int alignment in new[] { 0, 3, -3 })
{
// object, alignment
expected.AppendFormat("{0," + alignment.ToString(CultureInfo.InvariantCulture) + "}", o);
actual.AppendFormatted(o, alignment);
if (o is IHasToStringState tss3)
{
Assert.True(string.IsNullOrEmpty(tss3.ToStringState.LastFormat));
AssertModeMatchesType(tss3);
}
// object, alignment, format
expected.AppendFormat("{0," + alignment.ToString(CultureInfo.InvariantCulture) + ":X2}", o);
actual.AppendFormatted(o, alignment, "X2");
if (o is IHasToStringState tss4)
{
Assert.Equal("X2", tss4.ToStringState.LastFormat);
AssertModeMatchesType(tss4);
}
}
}
}
Assert.Equal(expected.ToString(), actual.ToStringAndClear());
}
static void TestManualDefaultStringInterpolationHandler()
{
Console.WriteLine("TestManualDefaultStringInterpolationHandler:");
C c = new C(42);
DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(0, 1);
defaultInterpolatedStringHandler.AppendFormatted(c);
M2(Space(), defaultInterpolatedStringHandler.ToStringAndClear());
}
public QueryInterpolatedStringHandler(int literalLength, int formattedCount)
{
_innerHandler = new DefaultInterpolatedStringHandler(literalLength, formattedCount);
// Default to a prepared query since we're using parameters
_queryOptions = new QueryOptions().AdHoc(false);
_parameterCount = 0;
}
public string Format <T0>(T0 arg0)
{
var builder = new DefaultInterpolatedStringHandler(2, 1, CultureInfo.InvariantCulture);
builder.AppendLiteral(_formatSegments[0]);
FormatArgument(ref builder, arg0, _valueAlignments[0], _valueFormats[0]);
builder.AppendLiteral(_formatSegments[1]);
return(builder.ToString());
}
public void ToString_DoesntClear()
{
DefaultInterpolatedStringHandler handler = new DefaultInterpolatedStringHandler(0, 0);
handler.AppendLiteral("hi");
for (int i = 0; i < 3; i++)
{
Assert.Equal("hi", handler.ToString());
}
Assert.Equal("hi", handler.ToStringAndClear());
}
public GuardInterpolatedStringHandler(int literalLength, int formattedCount, bool condition, out bool shouldAppend)
{
if (condition)
{
_innerHandler = default;
shouldAppend = false;
}
_innerHandler = new DefaultInterpolatedStringHandler(literalLength, formattedCount);
shouldAppend = true;
}
public void AppendLiteral()
{
var expected = new StringBuilder();
DefaultInterpolatedStringHandler actual = new DefaultInterpolatedStringHandler(0, 0);
foreach (string s in new[] { "", "a", "bc", "def", "this is a long string", "!" })
{
expected.Append(s);
actual.AppendLiteral(s);
}
Assert.Equal(expected.ToString(), actual.ToStringAndClear());
}
public void Grow_Large(bool useScratch)
{
var expected = new StringBuilder();
DefaultInterpolatedStringHandler handler = useScratch ?
new DefaultInterpolatedStringHandler(3, 1000, null, stackalloc char[16]) :
new DefaultInterpolatedStringHandler(3, 1000);
for (int i = 0; i < 1000; i++)
{
handler.AppendFormatted(i);
expected.Append(i);
handler.AppendFormatted(i, 3);
expected.AppendFormat("{0,3}", i);
}
Assert.Equal(expected.ToString(), handler.ToStringAndClear());
}
public void AppendFormatted_ValueTypes_ICustomFormatter()
{
var provider = new ConcatFormatter();
void Test <T>(T t)
{
void AssertTss(T tss, string format)
{
Assert.Equal(format, ((IHasToStringState)tss).ToStringState.LastFormat);
Assert.Same(provider, ((IHasToStringState)tss).ToStringState.LastProvider);
Assert.Equal(ToStringMode.ICustomFormatterFormat, ((IHasToStringState)tss).ToStringState.ToStringMode);
}
var expected = new StringBuilder();
DefaultInterpolatedStringHandler actual = new DefaultInterpolatedStringHandler(0, 0, provider);
// struct
expected.AppendFormat(provider, "{0}", t);
actual.AppendFormatted(t);
AssertTss(t, null);
// struct, format
expected.AppendFormat(provider, "{0:X2}", t);
actual.AppendFormatted(t, "X2");
AssertTss(t, "X2");
// struct, alignment
expected.AppendFormat(provider, "{0,3}", t);
actual.AppendFormatted(t, 3);
AssertTss(t, null);
// struct, alignment, format
expected.AppendFormat(provider, "{0,-3:X2}", t);
actual.AppendFormatted(t, -3, "X2");
AssertTss(t, "X2");
Assert.Equal(expected.ToString(), actual.ToStringAndClear());
}
Test(new FormattableInt32Wrapper(42));
Test(new SpanFormattableInt32Wrapper(84));
Test((FormattableInt32Wrapper?)new FormattableInt32Wrapper(42));
Test((SpanFormattableInt32Wrapper?)new SpanFormattableInt32Wrapper(84));
}
public string Format <T0, T1, T2, T3, T4, T5>(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
{
var builder = new DefaultInterpolatedStringHandler(7, 6, CultureInfo.InvariantCulture);
builder.AppendLiteral(_formatSegments[0]);
FormatArgument(ref builder, arg0, _valueAlignments[0], _valueFormats[0]);
builder.AppendLiteral(_formatSegments[1]);
FormatArgument(ref builder, arg1, _valueAlignments[1], _valueFormats[1]);
builder.AppendLiteral(_formatSegments[2]);
FormatArgument(ref builder, arg2, _valueAlignments[2], _valueFormats[2]);
builder.AppendLiteral(_formatSegments[3]);
FormatArgument(ref builder, arg3, _valueAlignments[3], _valueFormats[3]);
builder.AppendLiteral(_formatSegments[4]);
FormatArgument(ref builder, arg4, _valueAlignments[4], _valueFormats[4]);
builder.AppendLiteral(_formatSegments[5]);
FormatArgument(ref builder, arg5, _valueAlignments[5], _valueFormats[5]);
builder.AppendLiteral(_formatSegments[6]);
return(builder.ToString());
}
public void AppendFormatted_ReferenceTypes_ICustomFormatter()
{
var provider = new ConcatFormatter();
var expected = new StringBuilder();
DefaultInterpolatedStringHandler actual = new DefaultInterpolatedStringHandler(0, 0, provider);
foreach (string s in new[] { null, "", "a" })
{
foreach (IHasToStringState tss in new IHasToStringState[] { new FormattableStringWrapper(s), new SpanFormattableStringWrapper(s) })
{
void AssertTss(IHasToStringState tss, string format)
{
Assert.Equal(format, tss.ToStringState.LastFormat);
Assert.Same(provider, tss.ToStringState.LastProvider);
Assert.Equal(ToStringMode.ICustomFormatterFormat, tss.ToStringState.ToStringMode);
}
// object
expected.AppendFormat(provider, "{0}", tss);
actual.AppendFormatted(tss);
AssertTss(tss, null);
// object, format
expected.AppendFormat(provider, "{0:X2}", tss);
actual.AppendFormatted(tss, "X2");
AssertTss(tss, "X2");
// object, alignment
expected.AppendFormat(provider, "{0,3}", tss);
actual.AppendFormatted(tss, 3);
AssertTss(tss, null);
// object, alignment, format
expected.AppendFormat(provider, "{0,-3:X2}", tss);
actual.AppendFormatted(tss, -3, "X2");
AssertTss(tss, "X2");
}
}
Assert.Equal(expected.ToString(), actual.ToStringAndClear());
}
public void AppendFormatted_ValueTypes()
{
void Test <T>(T t)
{
var expected = new StringBuilder();
DefaultInterpolatedStringHandler actual = new DefaultInterpolatedStringHandler(0, 0);
// struct
expected.AppendFormat("{0}", t);
actual.AppendFormatted(t);
Assert.True(string.IsNullOrEmpty(((IHasToStringState)t).ToStringState.LastFormat));
AssertModeMatchesType(((IHasToStringState)t));
// struct, format
expected.AppendFormat("{0:X2}", t);
actual.AppendFormatted(t, "X2");
Assert.Equal("X2", ((IHasToStringState)t).ToStringState.LastFormat);
AssertModeMatchesType(((IHasToStringState)t));
foreach (int alignment in new[] { 0, 3, -3 })
{
// struct, alignment
expected.AppendFormat("{0," + alignment.ToString(CultureInfo.InvariantCulture) + "}", t);
actual.AppendFormatted(t, alignment);
Assert.True(string.IsNullOrEmpty(((IHasToStringState)t).ToStringState.LastFormat));
AssertModeMatchesType(((IHasToStringState)t));
// struct, alignment, format
expected.AppendFormat("{0," + alignment.ToString(CultureInfo.InvariantCulture) + ":X2}", t);
actual.AppendFormatted(t, alignment, "X2");
Assert.Equal("X2", ((IHasToStringState)t).ToStringState.LastFormat);
AssertModeMatchesType(((IHasToStringState)t));
}
Assert.Equal(expected.ToString(), actual.ToStringAndClear());
}
Test(new FormattableInt32Wrapper(42));
Test(new SpanFormattableInt32Wrapper(84));
Test((FormattableInt32Wrapper?)new FormattableInt32Wrapper(42));
Test((SpanFormattableInt32Wrapper?)new SpanFormattableInt32Wrapper(84));
}
public void AppendFormatted_ReferenceTypes_CreateProviderFlowed(bool useScratch)
{
var provider = new CultureInfo("en-US");
DefaultInterpolatedStringHandler handler = useScratch ?
new DefaultInterpolatedStringHandler(1, 2, provider, stackalloc char[16]) :
new DefaultInterpolatedStringHandler(1, 2, provider);
foreach (IHasToStringState tss in new IHasToStringState[] { new FormattableStringWrapper("hello"), new SpanFormattableStringWrapper("hello") })
{
handler.AppendFormatted(tss);
Assert.Same(provider, tss.ToStringState.LastProvider);
handler.AppendFormatted(tss, 1);
Assert.Same(provider, tss.ToStringState.LastProvider);
handler.AppendFormatted(tss, "X2");
Assert.Same(provider, tss.ToStringState.LastProvider);
handler.AppendFormatted(tss, 1, "X2");
Assert.Same(provider, tss.ToStringState.LastProvider);
}
}
public QueryInterpolatedStringHandler(int literalLength, int formattedCount, QueryOptions queryOptions)
{
_innerHandler = new DefaultInterpolatedStringHandler(literalLength, formattedCount);
_queryOptions = queryOptions;
_parameterCount = 0;
}
/// <summary>Creates a new string by using the specified provider to control the formatting of the specified interpolated string.</summary>
/// <param name="provider">An object that supplies culture-specific formatting information.</param>
/// <param name="initialBuffer">The initial buffer that may be used as temporary space as part of the formatting operation. The contents of this buffer may be overwritten.</param>
/// <param name="handler">The interpolated string.</param>
/// <returns>The string that results for formatting the interpolated string using the specified format provider.</returns>
public static string Create(IFormatProvider?provider, Span <char> initialBuffer, [InterpolatedStringHandlerArgument("provider", "initialBuffer")] ref DefaultInterpolatedStringHandler handler) =>
handler.ToStringAndClear();
/// <summary>Creates a new string by using the specified provider to control the formatting of the specified interpolated string.</summary> /// <param name="provider">An object that supplies culture-specific formatting information.</param> /// <param name="handler">The interpolated string.</param> /// <returns>The string that results for formatting the interpolated string using the specified format provider.</returns> public static string Create(IFormatProvider?provider, [InterpolatedStringHandlerArgument(nameof(provider))] ref DefaultInterpolatedStringHandler handler) => handler.ToStringAndClear();
/// <summary>Creates an instance of the handler..</summary>
/// <param name="literalLength">The number of constant characters outside of interpolation expressions in the interpolated string.</param>
/// <param name="formattedCount">The number of interpolation expressions in the interpolated string.</param>
/// <param name="condition">The condition Boolean passed to the <see cref="Debug"/> method.</param>
/// <param name="shouldAppend">A value indicating whether formatting should proceed.</param>
/// <remarks>This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.</remarks>
public WriteIfInterpolatedStringHandler(int literalLength, int formattedCount, bool condition, out bool shouldAppend)
{
if (condition)
{
// Only used in debug, but could be used on non-failure code paths, so use a cached builder.
_stringBuilderHandler = new StringBuilder.AppendInterpolatedStringHandler(literalLength, formattedCount,
StringBuilderCache.Acquire(DefaultInterpolatedStringHandler.GetDefaultLength(literalLength, formattedCount)));
shouldAppend = true;
}
else
{
_stringBuilderHandler = default;
shouldAppend = false;
}
}
/// <summary>Creates an instance of the handler..</summary>
/// <param name="literalLength">The number of constant characters outside of interpolation expressions in the interpolated string.</param>
/// <param name="formattedCount">The number of interpolation expressions in the interpolated string.</param>
/// <param name="condition">The condition Boolean passed to the <see cref="Debug"/> method.</param>
/// <param name="shouldAppend">A value indicating whether formatting should proceed.</param>
/// <remarks>This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.</remarks>
public WriteIfInterpolatedStringHandler(int literalLength, int formattedCount, bool condition, out bool shouldAppend)
{
if (condition)
{
_stringBuilderHandler = new StringBuilder.AppendInterpolatedStringHandler(literalLength, formattedCount, new StringBuilder(DefaultInterpolatedStringHandler.GetDefaultLength(literalLength, formattedCount)));
shouldAppend = true;
}
else
{
_stringBuilderHandler = default;
shouldAppend = false;
}
}
public LogStringHandler(int literalLength, int formattedCount, IFormatProvider?provider, Span <char> initialBuffer)
{
_handler = new DefaultInterpolatedStringHandler(literalLength, formattedCount, provider, initialBuffer);
Values = new Dictionary <string, object?>();
}
public LogStringHandler(int literalLength, int formattedCount)
{
_handler = new DefaultInterpolatedStringHandler(literalLength, formattedCount);
Values = new Dictionary <string, object?>();
}
