public void AppendFormatted_ReadOnlySpanChar()
{
var expected = new StringBuilder();
MemoryExtensions.TryWriteInterpolatedStringHandler actual = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, _largeBuffer, out _);
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.True(MemoryExtensions.TryWrite(_largeBuffer, ref actual, out int charsWritten));
Assert.Equal(expected.ToString(), _largeBuffer.AsSpan(0, charsWritten).ToString());
}
public void AppendFormatted_BufferTooSmall_CustomFormatter()
{
var buffer = new char[100];
var provider = new ConstFormatter(" ");
{
MemoryExtensions.TryWriteInterpolatedStringHandler b = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, buffer.AsSpan(0, 0), provider, out bool shouldAppend);
Assert.True(shouldAppend);
// don't use custom formatter
Assert.True(b.AppendLiteral(""));
Assert.True(b.AppendFormatted("".AsSpan()));
Assert.True(b.AppendFormatted("".AsSpan(), alignment: 0, format: "X2"));
// do use custom formatter
Assert.False(b.AppendFormatted((object)"", alignment: 0, format: "X2"));
Assert.False(b.AppendFormatted(null));
Assert.False(b.AppendFormatted(""));
Assert.False(b.AppendFormatted("", alignment: 0, format: "X2"));
Assert.False(b.AppendFormatted <string>(""));
Assert.False(b.AppendFormatted <string>("", alignment: 0));
Assert.False(b.AppendFormatted <string>("", format: "X2"));
Assert.False(b.AppendFormatted <string>("", alignment: 0, format: "X2"));
Assert.False(MemoryExtensions.TryWrite(buffer.AsSpan(0, 0), ref b, out int charsWritten));
Assert.Equal(0, charsWritten);
}
}
public void AppendFormatted_ReferenceTypes()
{
var expected = new StringBuilder();
MemoryExtensions.TryWriteInterpolatedStringHandler actual = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, _largeBuffer, out _);
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.True(MemoryExtensions.TryWrite(_largeBuffer, ref actual, out int charsWritten));
Assert.Equal(expected.ToString(), _largeBuffer.AsSpan(0, charsWritten).ToString());
}
public void AppendFormatted_String_ICustomFormatter()
{
var provider = new ConcatFormatter();
var expected = new StringBuilder();
MemoryExtensions.TryWriteInterpolatedStringHandler actual = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, _largeBuffer, provider, out _);
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.True(MemoryExtensions.TryWrite(_largeBuffer, ref actual, out int charsWritten));
Assert.Equal(expected.ToString(), _largeBuffer.AsSpan(0, charsWritten).ToString());
}
public void AppendFormatted_BufferTooSmall(int bufferLength)
{
var buffer = new char[bufferLength];
for (int i = 0; i <= 29; i++)
{
MemoryExtensions.TryWriteInterpolatedStringHandler b = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, buffer, out bool shouldAppend);
Assert.True(shouldAppend);
Assert.True(b.AppendLiteral(new string('s', bufferLength)));
bool result = i switch
{
0 => b.AppendLiteral(" "),
1 => b.AppendFormatted((object)" ", alignment: 0, format: "X2"),
2 => b.AppendFormatted(" "),
3 => b.AppendFormatted(" ", alignment: 0, format: "X2"),
4 => b.AppendFormatted <string>(" "),
5 => b.AppendFormatted <string>(" ", alignment: 0),
6 => b.AppendFormatted <string>(" ", format: "X2"),
7 => b.AppendFormatted <string>(" ", alignment: 0, format: "X2"),
8 => b.AppendFormatted(" ".AsSpan()),
9 => b.AppendFormatted(" ".AsSpan(), alignment: 0, format: "X2"),
10 => b.AppendFormatted(new FormattableStringWrapper(" ")),
11 => b.AppendFormatted(new FormattableStringWrapper(" "), alignment: 0),
12 => b.AppendFormatted(new FormattableStringWrapper(" "), format: "X2"),
13 => b.AppendFormatted(new FormattableStringWrapper(" "), alignment: 0, format: "X2"),
14 => b.AppendFormatted(new SpanFormattableStringWrapper(" ")),
15 => b.AppendFormatted(new SpanFormattableStringWrapper(" "), alignment: 0),
16 => b.AppendFormatted(new SpanFormattableStringWrapper(" "), format: "X2"),
17 => b.AppendFormatted(new SpanFormattableStringWrapper(" "), alignment: 0, format: "X2"),
18 => b.AppendFormatted(new FormattableInt32Wrapper(1)),
19 => b.AppendFormatted(new FormattableInt32Wrapper(1), alignment: 0),
20 => b.AppendFormatted(new FormattableInt32Wrapper(1), format: "X2"),
21 => b.AppendFormatted(new FormattableInt32Wrapper(1), alignment: 0, format: "X2"),
22 => b.AppendFormatted(new SpanFormattableInt32Wrapper(1)),
23 => b.AppendFormatted(new SpanFormattableInt32Wrapper(1), alignment: 0),
24 => b.AppendFormatted(new SpanFormattableInt32Wrapper(1), format: "X2"),
25 => b.AppendFormatted(new SpanFormattableInt32Wrapper(1), alignment: 0, format: "X2"),
26 => b.AppendFormatted <string>("", alignment: 1),
27 => b.AppendFormatted <string>("", alignment: -1),
28 => b.AppendFormatted <string>(" ", alignment: 1, format: "X2"),
29 => b.AppendFormatted <string>(" ", alignment: -1, format: "X2"),
_ => throw new Exception(),
};
Assert.False(result);
Assert.False(MemoryExtensions.TryWrite(buffer.AsSpan(0, 0), ref b, out int charsWritten));
Assert.Equal(0, charsWritten);
}
}
public void AppendLiteral()
{
var expected = new StringBuilder();
MemoryExtensions.TryWriteInterpolatedStringHandler actual = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, _largeBuffer, out _);
foreach (string s in new[] { "", "a", "bc", "def", "this is a long string", "!" })
{
expected.Append(s);
actual.AppendLiteral(s);
}
Assert.True(MemoryExtensions.TryWrite(_largeBuffer, ref actual, out int charsWritten));
Assert.Equal(expected.ToString(), _largeBuffer.AsSpan(0, charsWritten).ToString());
}
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();
MemoryExtensions.TryWriteInterpolatedStringHandler actual = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, _largeBuffer, provider, out _);
// 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.True(MemoryExtensions.TryWrite(_largeBuffer, ref actual, out int charsWritten));
Assert.Equal(expected.ToString(), _largeBuffer.AsSpan(0, charsWritten).ToString());
}
Test(new FormattableInt32Wrapper(42));
Test(new SpanFormattableInt32Wrapper(84));
Test((FormattableInt32Wrapper?)new FormattableInt32Wrapper(42));
Test((SpanFormattableInt32Wrapper?)new SpanFormattableInt32Wrapper(84));
}
public void AppendFormatted_ValueTypes()
{
void Test <T>(T t)
{
var expected = new StringBuilder();
MemoryExtensions.TryWriteInterpolatedStringHandler actual = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, _largeBuffer, out _);
// 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.True(MemoryExtensions.TryWrite(_largeBuffer, ref actual, out int charsWritten));
Assert.Equal(expected.ToString(), _largeBuffer.AsSpan(0, charsWritten).ToString());
}
Test(new FormattableInt32Wrapper(42));
Test(new SpanFormattableInt32Wrapper(84));
Test((FormattableInt32Wrapper?)new FormattableInt32Wrapper(42));
Test((SpanFormattableInt32Wrapper?)new SpanFormattableInt32Wrapper(84));
}
public void AppendFormatted_ReferenceTypes_ICustomFormatter()
{
var provider = new ConcatFormatter();
var expected = new StringBuilder();
MemoryExtensions.TryWriteInterpolatedStringHandler actual = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, _largeBuffer, provider, out _);
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.True(MemoryExtensions.TryWrite(_largeBuffer, ref actual, out int charsWritten));
Assert.Equal(expected.ToString(), _largeBuffer.AsSpan(0, charsWritten).ToString());
}
public void AppendFormatted_EmptyBuffer_ZeroLengthWritesSuccessful()
{
var buffer = new char[100];
MemoryExtensions.TryWriteInterpolatedStringHandler b = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, buffer.AsSpan(0, 0), out bool shouldAppend);
Assert.True(shouldAppend);
Assert.True(b.AppendLiteral(""));
Assert.True(b.AppendFormatted((object)"", alignment: 0, format: "X2"));
Assert.True(b.AppendFormatted(null));
Assert.True(b.AppendFormatted(""));
Assert.True(b.AppendFormatted("", alignment: 0, format: "X2"));
Assert.True(b.AppendFormatted <string>(""));
Assert.True(b.AppendFormatted <string>("", alignment: 0));
Assert.True(b.AppendFormatted <string>("", format: "X2"));
Assert.True(b.AppendFormatted <string>("", alignment: 0, format: "X2"));
Assert.True(b.AppendFormatted("".AsSpan()));
Assert.True(b.AppendFormatted("".AsSpan(), alignment: 0, format: "X2"));
Assert.True(MemoryExtensions.TryWrite(buffer.AsSpan(0, 0), ref b, out int charsWritten));
Assert.Equal(0, charsWritten);
}
