Arrange own static and explicit format methods

andreise · andreise · commit 0dcf84fa785c · 2025-11-09T00:51:32.000+04:00
diff --git a/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.Span.Explicit.cs b/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.Span.Explicit.cs
@@ -0,0 +1,75 @@
+﻿using System;
+
+namespace PrimeFuncPack.Core.Tests;
+
+partial class UnitFormatTests
+{
+	[Theory]
+	[MemberData(nameof(ExpectedFormatCases))]
+	public static void FormatToSpanExplicit_DestLengthIsEqual_ExpectSuccessResult((string? Format, string Expected) testCase)
+	{
+		var (format, expected) = (testCase.Format, testCase.Expected.ToCharArray());
+
+		var destination = new char[expected.Length];
+
+		var source = (ISpanFormattable)default(Unit);
+		var actualResult = source.TryFormat(destination, out var actualCharsWritten, format, null);
+
+		Assert.True(actualResult);
+		Assert.Equal(expected.Length, actualCharsWritten);
+		Assert.Equal(expected, destination);
+	}
+
+	[Theory]
+	[MemberData(nameof(ExpectedFormatCases))]
+	public static void FormatToSpanExplicit_DestLengthIsGreater_ExpectSuccessResult((string? Format, string Expected) testCase)
+	{
+		var (format, expected) = (testCase.Format, testCase.Expected.ToCharArray());
+
+		const int extraLength = 1;
+		const char filler = 'X';
+
+		var destination = new char[expected.Length + extraLength];
+		destination.AsSpan(start: expected.Length).Fill(filler);
+
+		var source = (ISpanFormattable)default(Unit);
+		var actualResult = source.TryFormat(destination, out var actualCharsWritten, format, null);
+
+		Assert.True(actualResult);
+		Assert.Equal(expected.Length, actualCharsWritten);
+		Assert.Equal(expected, destination[..expected.Length]);
+
+		var expectedExtra = new char[extraLength];
+		expectedExtra.AsSpan().Fill(filler);
+		Assert.Equal(expectedExtra, destination[expected.Length..]);
+	}
+
+	[Theory]
+	[MemberData(nameof(ExpectedFormatCases))]
+	public static void FormatToSpanExplicit_DestLengthIsLess_ExpectFailureResult((string? Format, string Expected) testCase)
+	{
+		var (format, expectedLength) = (testCase.Format, testCase.Expected.Length);
+
+		if (expectedLength == 0)
+		{
+			// Skip inapplicable case
+			Assert.False(false);
+			return;
+		}
+
+		const char filler = 'X';
+
+		var destination = new char[expectedLength - 1];
+		destination.AsSpan().Fill(filler);
+
+		var source = (ISpanFormattable)default(Unit);
+		var actualResult = source.TryFormat(destination, out var actualCharsWritten, format, null);
+
+		Assert.False(actualResult);
+		Assert.Equal(0, actualCharsWritten);
+
+		var expectedDestination = new char[destination.Length];
+		expectedDestination.AsSpan().Fill(filler);
+		Assert.Equal(expectedDestination, destination);
+	}
+}
diff --git a/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.Span.Utf8.Explicit.cs b/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.Span.Utf8.Explicit.cs
@@ -0,0 +1,76 @@
+﻿using System;
+using System.Text;
+
+namespace PrimeFuncPack.Core.Tests;
+
+partial class UnitFormatTests
+{
+	[Theory]
+	[MemberData(nameof(ExpectedFormatCases))]
+	public static void FormatToSpanUtf8Explicit_DestLengthIsEqual_ExpectSuccessResult((string? Format, string Expected) testCase)
+	{
+		var (format, expected) = (testCase.Format, Encoding.UTF8.GetBytes(testCase.Expected));
+
+		var destination = new byte[expected.Length];
+
+		var source = (IUtf8SpanFormattable)default(Unit);
+		var actualResult = source.TryFormat(destination, out var actualCharsWritten, format, null);
+
+		Assert.True(actualResult);
+		Assert.Equal(expected.Length, actualCharsWritten);
+		Assert.Equal(expected, destination);
+	}
+
+	[Theory]
+	[MemberData(nameof(ExpectedFormatCases))]
+	public static void FormatToSpanUtf8Explicit_DestLengthIsGreater_ExpectSuccessResult((string? Format, string Expected) testCase)
+	{
+		var (format, expected) = (testCase.Format, Encoding.UTF8.GetBytes(testCase.Expected));
+
+		const int extraLength = 1;
+		const byte filler = byte.MaxValue;
+
+		var destination = new byte[expected.Length + extraLength];
+		destination.AsSpan(start: expected.Length).Fill(filler);
+
+		var source = (IUtf8SpanFormattable)default(Unit);
+		var actualResult = source.TryFormat(destination, out var actualCharsWritten, format, null);
+
+		Assert.True(actualResult);
+		Assert.Equal(expected.Length, actualCharsWritten);
+		Assert.Equal(expected, destination[..expected.Length]);
+
+		var expectedExtra = new byte[extraLength];
+		expectedExtra.AsSpan().Fill(filler);
+		Assert.Equal(expectedExtra, destination[expected.Length..]);
+	}
+
+	[Theory]
+	[MemberData(nameof(ExpectedFormatCases))]
+	public static void FormatToSpanUtf8Explicit_DestLengthIsLess_ExpectFailureResult((string? Format, string Expected) testCase)
+	{
+		var (format, expectedLength) = (testCase.Format, Encoding.UTF8.GetBytes(testCase.Expected).Length);
+
+		if (expectedLength == 0)
+		{
+			// Skip inapplicable case
+			Assert.False(false);
+			return;
+		}
+
+		const byte filler = byte.MaxValue;
+
+		var destination = new byte[expectedLength - 1];
+		destination.AsSpan().Fill(filler);
+
+		var source = (IUtf8SpanFormattable)default(Unit);
+		var actualResult = source.TryFormat(destination, out var actualCharsWritten, format, null);
+
+		Assert.False(actualResult);
+		Assert.Equal(0, actualCharsWritten);
+
+		var expectedDestination = new byte[destination.Length];
+		expectedDestination.AsSpan().Fill(filler);
+		Assert.Equal(expectedDestination, destination);
+	}
+}
diff --git a/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.Span.Utf8.cs b/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.Span.Utf8.cs
@@ -13,8 +13,7 @@ public static void FormatToSpanUtf8_DestLengthIsEqual_ExpectSuccessResult((strin
 
 		var destination = new byte[expected.Length];
 
-		var source = default(Unit);
-		var actualResult = source.TryFormat(destination.AsSpan(), out var actualCharsWritten, format, null);
+		var actualResult = Unit.TryFormat(destination, out var actualCharsWritten, format);
 
 		Assert.True(actualResult);
 		Assert.Equal(expected.Length, actualCharsWritten);
@@ -33,8 +32,7 @@ public static void FormatToSpanUtf8_DestLengthIsGreater_ExpectSuccessResult((str
 		var destination = new byte[expected.Length + extraLength];
 		destination.AsSpan(start: expected.Length).Fill(filler);
 
-		var source = default(Unit);
-		var actualResult = source.TryFormat(destination.AsSpan(), out var actualCharsWritten, format, null);
+		var actualResult = Unit.TryFormat(destination, out var actualCharsWritten, format);
 
 		Assert.True(actualResult);
 		Assert.Equal(expected.Length, actualCharsWritten);
@@ -63,8 +61,7 @@ public static void FormatToSpanUtf8_DestLengthIsLess_ExpectFailureResult((string
 		var destination = new byte[expectedLength - 1];
 		destination.AsSpan().Fill(filler);
 
-		var source = default(Unit);
-		var actualResult = source.TryFormat(destination.AsSpan(), out var actualCharsWritten, format, null);
+		var actualResult = Unit.TryFormat(destination, out var actualCharsWritten, format);
 
 		Assert.False(actualResult);
 		Assert.Equal(0, actualCharsWritten);
diff --git a/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.Span.cs b/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.Span.cs
@@ -12,8 +12,7 @@ public static void FormatToSpan_DestLengthIsEqual_ExpectSuccessResult((string? F
 
 		var destination = new char[expected.Length];
 
-		var source = default(Unit);
-		var actualResult = source.TryFormat(destination.AsSpan(), out var actualCharsWritten, format, null);
+		var actualResult = Unit.TryFormat(destination, out var actualCharsWritten, format);
 
 		Assert.True(actualResult);
 		Assert.Equal(expected.Length, actualCharsWritten);
@@ -32,8 +31,7 @@ public static void FormatToSpan_DestLengthIsGreater_ExpectSuccessResult((string?
 		var destination = new char[expected.Length + extraLength];
 		destination.AsSpan(start: expected.Length).Fill(filler);
 
-		var source = default(Unit);
-		var actualResult = source.TryFormat(destination.AsSpan(), out var actualCharsWritten, format, null);
+		var actualResult = Unit.TryFormat(destination, out var actualCharsWritten, format);
 
 		Assert.True(actualResult);
 		Assert.Equal(expected.Length, actualCharsWritten);
@@ -62,8 +60,7 @@ public static void FormatToSpan_DestLengthIsLess_ExpectFailureResult((string? Fo
 		var destination = new char[expectedLength - 1];
 		destination.AsSpan().Fill(filler);
 
-		var source = default(Unit);
-		var actualResult = source.TryFormat(destination.AsSpan(), out var actualCharsWritten, format, null);
+		var actualResult = Unit.TryFormat(destination, out var actualCharsWritten, format);
 
 		Assert.False(actualResult);
 		Assert.Equal(0, actualCharsWritten);
diff --git a/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.String.Explicit.cs b/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.String.Explicit.cs
@@ -0,0 +1,16 @@
+﻿using System;
+
+namespace PrimeFuncPack.Core.Tests;
+
+partial class UnitFormatTests
+{
+	[Theory]
+	[MemberData(nameof(ExpectedFormatCases))]
+	public static void FormatToStringExplicit_ExpectCorrespondingResult((string? Format, string Expected) testCase)
+	{
+		var source = (IFormattable)default(Unit);
+		var actual = source.ToString(testCase.Format, null);
+
+		Assert.Equal(testCase.Expected, actual);
+	}
+}
diff --git a/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.String.cs b/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Format.String.cs
@@ -8,8 +8,7 @@ partial class UnitFormatTests
 	[MemberData(nameof(ExpectedFormatCases))]
 	public static void FormatToString_ExpectCorrespondingResult((string? Format, string Expected) testCase)
 	{
-		var source = default(Unit);
-		var actual = source.ToString(testCase.Format, null);
+		var actual = Unit.Format(testCase.Format);
 
 		Assert.Equal(testCase.Expected, actual);
 	}
diff --git a/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Parse.Span.Explicit.cs b/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Parse.Span.Explicit.cs
@@ -6,17 +6,17 @@ partial class UnitFormatTests
 {
 	[Theory]
 	[MemberData(nameof(ParseCases))]
-	public static void ParseSpan_Succeeds(string? s)
+	public static void ParseSpanExplicit_Succeeds(string? s)
 		=>
-		Inner_ParseSpan_Succeeds<Unit>(s);
+		Inner_ParseSpanExplicit_Succeeds<Unit>(s);
 
 	[Theory]
 	[MemberData(nameof(ParseCases))]
-	public static void TryParseSpan_Succeeds(string? s)
+	public static void TryParseSpanExplicit_Succeeds(string? s)
 		=>
-		Inner_TryParseSpan_Succeeds<Unit>(s);
+		Inner_TryParseSpanExplicit_Succeeds<Unit>(s);
 
-	private static void Inner_ParseSpan_Succeeds<TUnit>(string? s)
+	private static void Inner_ParseSpanExplicit_Succeeds<TUnit>(string? s)
 		where TUnit : struct, ISpanParsable<TUnit>
 	{
 		ReadOnlySpan<char> span = s;
@@ -27,7 +27,7 @@ private static void Inner_ParseSpan_Succeeds<TUnit>(string? s)
 		Assert.StrictEqual(expected, actual);
 	}
 
-	private static void Inner_TryParseSpan_Succeeds<TUnit>(string? s)
+	private static void Inner_TryParseSpanExplicit_Succeeds<TUnit>(string? s)
 		where TUnit : struct, ISpanParsable<TUnit>
 	{
 		ReadOnlySpan<char> span = s;
diff --git a/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Parse.Span.Utf8.Explicit.cs b/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Parse.Span.Utf8.Explicit.cs
@@ -7,17 +7,17 @@ partial class UnitFormatTests
 {
 	[Theory]
 	[MemberData(nameof(ParseCases))]
-	public static void ParseSpanUtf8_Succeeds(string? s)
+	public static void ParseSpanUtf8Explicit_Succeeds(string? s)
 		=>
-		Inner_ParseSpanUtf8_Succeeds<Unit>(s);
+		Inner_ParseSpanUtf8Explicit_Succeeds<Unit>(s);
 
 	[Theory]
 	[MemberData(nameof(ParseCases))]
-	public static void TryParseSpanUtf8_Succeeds(string? s)
+	public static void TryParseSpanUtf8Explicit_Succeeds(string? s)
 		=>
-		Inner_TryParseSpanUtf8_Succeeds<Unit>(s);
+		Inner_TryParseSpanUtf8Explicit_Succeeds<Unit>(s);
 
-	private static void Inner_ParseSpanUtf8_Succeeds<TUnit>(string? s)
+	private static void Inner_ParseSpanUtf8Explicit_Succeeds<TUnit>(string? s)
 		where TUnit : struct, IUtf8SpanParsable<TUnit>
 	{
 		ReadOnlySpan<byte> span = s is null ? null : Encoding.UTF8.GetBytes(s);
@@ -28,7 +28,7 @@ private static void Inner_ParseSpanUtf8_Succeeds<TUnit>(string? s)
 		Assert.StrictEqual(expected, actual);
 	}
 
-	private static void Inner_TryParseSpanUtf8_Succeeds<TUnit>(string? s)
+	private static void Inner_TryParseSpanUtf8Explicit_Succeeds<TUnit>(string? s)
 		where TUnit : struct, IUtf8SpanParsable<TUnit>
 	{
 		ReadOnlySpan<byte> span = s is null ? null : Encoding.UTF8.GetBytes(s);
diff --git a/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Parse.String.Explicit.cs b/src/core-unit/Unit.Tests/UnitFormatTests/UnitFormatTests.Parse.String.Explicit.cs
@@ -6,17 +6,17 @@ partial class UnitFormatTests
 {
 	[Theory]
 	[MemberData(nameof(ParseCases))]
-	public static void ParseString_Succeeds(string? s)
+	public static void ParseStringExplicit_Succeeds(string? s)
 		=>
-		Inner_ParseString_Succeeds<Unit>(s);
+		Inner_ParseStringExplicit_Succeeds<Unit>(s);
 
 	[Theory]
 	[MemberData(nameof(ParseCases))]
-	public static void TryParseString_Succeeds(string? s)
+	public static void TryParseStringExplicit_Succeeds(string? s)
 		=>
-		Inner_TryParseString_Succeeds<Unit>(s);
+		Inner_TryParseStringExplicit_Succeeds<Unit>(s);
 
-	private static void Inner_ParseString_Succeeds<TUnit>(string? s)
+	private static void Inner_ParseStringExplicit_Succeeds<TUnit>(string? s)
 		where TUnit : struct, IParsable<TUnit>
 	{
 		var actual = TUnit.Parse(s!, null);
@@ -26,7 +26,7 @@ private static void Inner_ParseString_Succeeds<TUnit>(string? s)
 		Assert.StrictEqual(expected, actual);
 	}
 
-	private static void Inner_TryParseString_Succeeds<TUnit>(string? s)
+	private static void Inner_TryParseStringExplicit_Succeeds<TUnit>(string? s)
 		where TUnit : struct, IParsable<TUnit>
 	{
 		var actual = TUnit.TryParse(s, null, out var result);
diff --git a/src/core-unit/Unit/Unit/Unit.Format.Explicit.cs b/src/core-unit/Unit/Unit/Unit.Format.Explicit.cs
@@ -0,0 +1,16 @@
+﻿namespace System;
+
+partial struct Unit
+{
+	string IFormattable.ToString(string? format, IFormatProvider? formatProvider)
+		=>
+		Format(format);
+
+	bool ISpanFormattable.TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+		=>
+		TryFormat(destination, out charsWritten, format);
+
+	bool IUtf8SpanFormattable.TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+		=>
+		TryFormat(utf8Destination, out bytesWritten, format);
+}
diff --git a/src/core-unit/Unit/Unit/Unit.Format.Static.cs b/src/core-unit/Unit/Unit/Unit.Format.Static.cs
@@ -4,15 +4,11 @@ namespace System;
 
 partial struct Unit
 {
-	// IFormattable
-
-	public string ToString(string? format, IFormatProvider? formatProvider)
+	public static string Format(ReadOnlySpan<char> format)
 		=>
 		UnitFormatter.Format(format);
 
-	// ISpanFormattable
-
-	public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+	public static bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format)
 	{
 		var formatted = UnitFormatter.Format(format);
 
@@ -22,9 +18,7 @@ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan
 		return result;
 	}
 
-	// IUtf8SpanFormattable
-
-	public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+	public static bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format)
 	{
 		ReadOnlySpan<byte> utf8Formatted = new(Encoding.UTF8.GetBytes(UnitFormatter.Format(format)));
 
diff --git a/src/core-unit/Unit/Unit/Unit.Parse.Static.Explicit.cs b/src/core-unit/Unit/Unit/Unit.Parse.Static.Explicit.cs

Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,7 @@ partial class UnitFormatTests`
`8`	`8`	`[MemberData(nameof(ExpectedFormatCases))]`
`9`	`9`	`public static void FormatToString_ExpectCorrespondingResult((string? Format, string Expected) testCase)`
`10`	`10`	`{`
`11`		`- var source = default(Unit);`
`12`		`- var actual = source.ToString(testCase.Format, null);`
	`11`	`+ var actual = Unit.Format(testCase.Format);`
`13`	`12`
`14`	`13`	`Assert.Equal(testCase.Expected, actual);`
`15`	`14`	`}`