Summary

Class:	System.Buffers.Text.Utf8Formatter
Assembly:	System.Memory
File(s):	C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Boolean.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Date.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Date.G.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Date.L.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Date.O.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Date.R.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Decimal.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Decimal.E.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Decimal.F.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Decimal.G.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Float.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Guid.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Signed.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Signed.D.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Signed.Default.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Signed.N.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Unsigned.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Unsigned.D.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Unsigned.Default.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Unsigned.N.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Unsigned.X.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.TimeSpan.cs
Covered lines:	998
Uncovered lines:	122
Coverable lines:	1120
Total lines:	2473
Line coverage:	89.1%
Branch coverage:	91.3%

Metrics

Method	Cyclomatic complexity	NPath complexity	Sequence coverage	Branch coverage
TryFormat(...)	10	512	95.65	94.74
TryFormat(...)	7	32	100	100
TryFormat(...)	6	16	100	100
.cctor()	1	0	100	100
TryFormatDateTimeG(...)	5	16	100	100
TryFormatDateTimeO(...)	8	128	100	100
TryFormatDateTimeR(...)	2	2	100	100
TryFormatDateTimeL(...)	2	2	100	100
TryFormat(...)	20	8192	100	100
TryFormatDecimalE(...)	12	512	100	100
TryFormatDecimalF(...)	18	16384	100	100
TryFormatDecimalG(...)	16	16384	100	100
TryFormat(...)	1	0	100	100
TryFormat(...)	1	0	100	100
TryFormatFloatingPoint(...)	9	256	100	100
TryFormat(...)	13	2048	100	100
TryFormat(...)	1	0	100	100
TryFormat(...)	1	0	100	100
TryFormat(...)	1	0	100	100
TryFormat(...)	1	0	100	100
TryFormat(...)	1	0	100	100
TryFormat(...)	1	0	100	100
TryFormat(...)	1	0	100	100
TryFormat(...)	1	0	100	100
TryFormatInt64(...)	14	1024	100	90.48
TryFormatInt64D(...)	3	4	100	100
TryFormatInt64D_MinValue(...)	2	2	100	100
TryFormatInt64Default(...)	9	16	44.44	44.44
TryFormatInt32MultipleDigits(...)	3	4	0	0
TryFormatInt64MultipleDigits(...)	3	4	100	100
TryFormatInt64MoreThanNegativeBillionMaxUInt(...)	3	2	0	0
TryFormatInt64LessThanNegativeBillionMaxUInt(...)	2	2	0	0
TryFormatInt64N(...)	3	4	100	100
TryFormatInt64N_MinValue(...)	2	2	100	100
TryFormatUInt64(...)	14	1024	100	90.48
TryFormatUInt64D(...)	8	64	100	100
TryFormatUInt64Default(...)	5	16	44.44	44.44
TryFormatUInt32SingleDigit(...)	2	2	100	100
TryFormatUInt32MultipleDigits(...)	2	2	0	0
TryFormatUInt64MultipleDigits(...)	2	2	100	100
TryFormatUInt64LessThanBillionMaxUInt(...)	3	2	0	0
TryFormatUInt64MoreThanBillionMaxUInt(...)	3	2	0	0
TryFormatUInt64N(...)	8	64	100	100
TryFormatUInt64X(...)	6	8	100	100
TryFormat(...)	28	16777216	98.4	93.88

File(s)

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Boolean.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Buffers.Binary;
		6
		7		namespace System.Buffers.Text
		8		{
		9		public static partial class Utf8Formatter
		10		{
		11		/// <summary>
		12		/// Formats a Boolean as a UTF8 string.
		13		/// </summary>
		14		/// <param name="value">Value to format</param>
		15		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		16		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		17		/// <param name="format">The standard format to use</param>
		18		/// <returns>
		19		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		20		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		21		/// </returns>
		22		/// <remarks>
		23		/// Formats supported:
		24		///     G (default)   True/False
		25		///     l             true/false
		26		/// </remarks>
		27		/// <exceptions>
		28		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		29		/// </exceptions>
		30		public static bool TryFormat(bool value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defaul
	1	31		{
	1	32		char symbol = FormattingHelpers.GetSymbolOrDefault(format, 'G');
		33
	1	34		if (value)
	1	35		{
	1	36		if (symbol == 'G')
	1	37		{
		38		// By having each branch perform its own call to TryWriteUInt32BigEndian, we ensure that a
		39		// constant value is passed to this routine, which means the compiler can reverse endianness
		40		// at compile time instead of runtime if necessary.
		41		const uint TrueValueUppercase = ('T' << 24) + ('r' << 16) + ('u' << 8) + ('e' << 0);
	1	42		if (!BinaryPrimitives.TryWriteUInt32BigEndian(buffer, TrueValueUppercase))
	1	43		{
	1	44		goto BufferTooSmall;
		45		}
	1	46		}
	1	47		else if (symbol == 'l')
	1	48		{
		49		const uint TrueValueLowercase = ('t' << 24) + ('r' << 16) + ('u' << 8) + ('e' << 0);
	1	50		if (!BinaryPrimitives.TryWriteUInt32BigEndian(buffer, TrueValueLowercase))
	1	51		{
	1	52		goto BufferTooSmall;
		53		}
	1	54		}
		55		else
	0	56		{
	0	57		goto BadFormat;
		58		}
		59
	1	60		bytesWritten = 4;
	1	61		return true;
		62		}
		63		else
	1	64		{
	1	65		if (symbol == 'G')
	1	66		{
		67		// This check can't be performed earlier because we need to throw if an invalid symbol is
		68		// provided, even if the buffer is too small.
	1	69		if ((uint)4 >= (uint)buffer.Length)
	1	70		{
	1	71		goto BufferTooSmall;
		72		}
		73
		74		const uint FalsValueUppercase = ('F' << 24) + ('a' << 16) + ('l' << 8) + ('s' << 0);
	1	75		BinaryPrimitives.WriteUInt32BigEndian(buffer, FalsValueUppercase);
	1	76		}
	1	77		else if (symbol == 'l')
	1	78		{
	1	79		if ((uint)4 >= (uint)buffer.Length)
	1	80		{
	1	81		goto BufferTooSmall;
		82		}
		83
		84		const uint FalsValueLowercase = ('f' << 24) + ('a' << 16) + ('l' << 8) + ('s' << 0);
	1	85		BinaryPrimitives.WriteUInt32BigEndian(buffer, FalsValueLowercase);
	1	86		}
		87		else
	1	88		{
	1	89		goto BadFormat;
		90		}
		91
	1	92		buffer[4] = (byte)'e';
	1	93		bytesWritten = 5;
	1	94		return true;
		95		}
		96
	1	97		BufferTooSmall:
	1	98		bytesWritten = 0;
	1	99		return false;
		100
	1	101		BadFormat:
	1	102		return ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
	1	103		}
		104		}
		105		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Date.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Formatter
		8		{
		9		private const byte TimeMarker = (byte)'T';
		10		private const byte UtcMarker = (byte)'Z';
		11
		12		private const byte GMT1 = (byte)'G';
		13		private const byte GMT2 = (byte)'M';
		14		private const byte GMT3 = (byte)'T';
		15
		16		private const byte GMT1Lowercase = (byte)'g';
		17		private const byte GMT2Lowercase = (byte)'m';
		18		private const byte GMT3Lowercase = (byte)'t';
		19
		20		// The three-letter abbreviation is packed into a 24-bit unsigned integer
		21		// where the least significant byte represents the first letter.
	1	22		private static readonly uint[] DayAbbreviations = new uint[]
	1	23		{
	1	24		'S' + ('u' << 8) + ('n' << 16),
	1	25		'M' + ('o' << 8) + ('n' << 16),
	1	26		'T' + ('u' << 8) + ('e' << 16),
	1	27		'W' + ('e' << 8) + ('d' << 16),
	1	28		'T' + ('h' << 8) + ('u' << 16),
	1	29		'F' + ('r' << 8) + ('i' << 16),
	1	30		'S' + ('a' << 8) + ('t' << 16),
	1	31		};
		32
	1	33		private static readonly uint[] DayAbbreviationsLowercase = new uint[]
	1	34		{
	1	35		's' + ('u' << 8) + ('n' << 16),
	1	36		'm' + ('o' << 8) + ('n' << 16),
	1	37		't' + ('u' << 8) + ('e' << 16),
	1	38		'w' + ('e' << 8) + ('d' << 16),
	1	39		't' + ('h' << 8) + ('u' << 16),
	1	40		'f' + ('r' << 8) + ('i' << 16),
	1	41		's' + ('a' << 8) + ('t' << 16)
	1	42		};
		43
	1	44		private static readonly uint[] MonthAbbreviations = new uint[]
	1	45		{
	1	46		'J' + ('a' << 8) + ('n' << 16),
	1	47		'F' + ('e' << 8) + ('b' << 16),
	1	48		'M' + ('a' << 8) + ('r' << 16),
	1	49		'A' + ('p' << 8) + ('r' << 16),
	1	50		'M' + ('a' << 8) + ('y' << 16),
	1	51		'J' + ('u' << 8) + ('n' << 16),
	1	52		'J' + ('u' << 8) + ('l' << 16),
	1	53		'A' + ('u' << 8) + ('g' << 16),
	1	54		'S' + ('e' << 8) + ('p' << 16),
	1	55		'O' + ('c' << 8) + ('t' << 16),
	1	56		'N' + ('o' << 8) + ('v' << 16),
	1	57		'D' + ('e' << 8) + ('c' << 16),
	1	58		};
		59
	1	60		private static readonly uint[] MonthAbbreviationsLowercase = new uint[]
	1	61		{
	1	62		'j' + ('a' << 8) + ('n' << 16),
	1	63		'f' + ('e' << 8) + ('b' << 16),
	1	64		'm' + ('a' << 8) + ('r' << 16),
	1	65		'a' + ('p' << 8) + ('r' << 16),
	1	66		'm' + ('a' << 8) + ('y' << 16),
	1	67		'j' + ('u' << 8) + ('n' << 16),
	1	68		'j' + ('u' << 8) + ('l' << 16),
	1	69		'a' + ('u' << 8) + ('g' << 16),
	1	70		's' + ('e' << 8) + ('p' << 16),
	1	71		'o' + ('c' << 8) + ('t' << 16),
	1	72		'n' + ('o' << 8) + ('v' << 16),
	1	73		'd' + ('e' << 8) + ('c' << 16),
	1	74		};
		75
		76		/// <summary>
		77		/// Formats a DateTimeOffset as a UTF8 string.
		78		/// </summary>
		79		/// <param name="value">Value to format</param>
		80		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		81		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		82		/// <param name="format">The standard format to use</param>
		83		/// <returns>
		84		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		85		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		86		/// </returns>
		87		/// <exceptions>
		88		/// <remarks>
		89		/// Formats supported:
		90		///     default       05/25/2017 10:30:15 -08:00
		91		///     G             05/25/2017 10:30:15
		92		///     R             Tue, 03 Jan 2017 08:08:05 GMT       (RFC 1123)
		93		///     l             tue, 03 jan 2017 08:08:05 gmt       (Lowercase RFC 1123)
		94		///     O             2017-06-12T05:30:45.7680000-07:00   (Round-trippable)
		95		/// </remarks>
		96		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		97		/// </exceptions>
		98		public static bool TryFormat(DateTimeOffset value, Span<byte> buffer, out int bytesWritten, StandardFormat forma
	1	99		{
	1	100		TimeSpan offset = Utf8Constants.s_nullUtcOffset;
	1	101		char symbol = format.Symbol;
	1	102		if (format.IsDefault)
	1	103		{
	1	104		symbol = 'G';
	1	105		offset = value.Offset;
	1	106		}
		107
	1	108		switch (symbol)
		109		{
		110		case 'R':
	1	111		return TryFormatDateTimeR(value.UtcDateTime, buffer, out bytesWritten);
		112
		113		case 'l':
	1	114		return TryFormatDateTimeL(value.UtcDateTime, buffer, out bytesWritten);
		115
		116		case 'O':
	1	117		return TryFormatDateTimeO(value.DateTime, value.Offset, buffer, out bytesWritten);
		118
		119		case 'G':
	1	120		return TryFormatDateTimeG(value.DateTime, offset, buffer, out bytesWritten);
		121
		122		default:
	1	123		return ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
		124		}
	1	125		}
		126
		127		/// <summary>
		128		/// Formats a DateTime as a UTF8 string.
		129		/// </summary>
		130		/// <param name="value">Value to format</param>
		131		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		132		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		133		/// <param name="format">The standard format to use</param>
		134		/// <returns>
		135		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		136		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		137		/// </returns>
		138		/// <remarks>
		139		/// Formats supported:
		140		///     G  (default)  05/25/2017 10:30:15
		141		///     R             Tue, 03 Jan 2017 08:08:05 GMT       (RFC 1123)
		142		///     l             tue, 03 jan 2017 08:08:05 gmt       (Lowercase RFC 1123)
		143		///     O             2017-06-12T05:30:45.7680000-07:00   (Round-trippable)
		144		/// </remarks>
		145		/// <exceptions>
		146		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		147		/// </exceptions>
		148		public static bool TryFormat(DateTime value, Span<byte> buffer, out int bytesWritten, StandardFormat format = de
	1	149		{
	1	150		char symbol = FormattingHelpers.GetSymbolOrDefault(format, 'G');
		151
	1	152		switch (symbol)
		153		{
		154		case 'R':
	1	155		return TryFormatDateTimeR(value, buffer, out bytesWritten);
		156
		157		case 'l':
	1	158		return TryFormatDateTimeL(value, buffer, out bytesWritten);
		159
		160		case 'O':
	1	161		return TryFormatDateTimeO(value, Utf8Constants.s_nullUtcOffset, buffer, out bytesWritten);
		162
		163		case 'G':
	1	164		return TryFormatDateTimeG(value, Utf8Constants.s_nullUtcOffset, buffer, out bytesWritten);
		165
		166		default:
	1	167		return ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
		168		}
	1	169		}
		170		}
		171		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Date.G.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Formatter
		8		{
		9		//
		10		// 'G' format for DateTime.
		11		//
		12		//    0123456789012345678
		13		//    ---------------------------------
		14		//    05/25/2017 10:30:15
		15		//
		16		//  Also handles the default ToString() format for DateTimeOffset
		17		//
		18		//    01234567890123456789012345
		19		//    --------------------------
		20		//    05/25/2017 10:30:15 -08:00
		21		//
		22		private static bool TryFormatDateTimeG(DateTime value, TimeSpan offset, Span<byte> buffer, out int bytesWritten)
	1	23		{
		24		const int MinimumBytesNeeded = 19;
		25
	1	26		int bytesRequired = MinimumBytesNeeded;
		27
	1	28		if (offset != Utf8Constants.s_nullUtcOffset)
	1	29		{
	1	30		bytesRequired += 7; // Space['+'|'-']hh:mm
	1	31		}
		32
	1	33		if (buffer.Length < bytesRequired)
	1	34		{
	1	35		bytesWritten = 0;
	1	36		return false;
		37		}
		38
	1	39		bytesWritten = bytesRequired;
		40
		41		// Hoist most of the bounds checks on buffer.
	3	42		{ var unused = buffer[MinimumBytesNeeded - 1]; }
		43
		44		// TODO: Introduce an API which can parse DateTime instances efficiently, pulling out
		45		// all their properties (Month, Day, etc.) in one shot. This would help avoid the
		46		// duplicate work that implicitly results from calling these properties individually.
		47
	1	48		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Month, buffer, 0);
	1	49		buffer[2] = Utf8Constants.Slash;
		50
	1	51		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Day, buffer, 3);
	1	52		buffer[5] = Utf8Constants.Slash;
		53
	1	54		FormattingHelpers.WriteFourDecimalDigits((uint)value.Year, buffer, 6);
	1	55		buffer[10] = Utf8Constants.Space;
		56
	1	57		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Hour, buffer, 11);
	1	58		buffer[13] = Utf8Constants.Colon;
		59
	1	60		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Minute, buffer, 14);
	1	61		buffer[16] = Utf8Constants.Colon;
		62
	1	63		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Second, buffer, 17);
		64
	1	65		if (offset != Utf8Constants.s_nullUtcOffset)
	1	66		{
		67		byte sign;
		68
	1	69		if (offset < default(TimeSpan) /* a "const" version of TimeSpan.Zero */)
	1	70		{
	1	71		sign = Utf8Constants.Minus;
	1	72		offset = TimeSpan.FromTicks(-offset.Ticks);
	1	73		}
		74		else
	1	75		{
	1	76		sign = Utf8Constants.Plus;
	1	77		}
		78
		79		// Writing the value backward allows the JIT to optimize by
		80		// performing a single bounds check against buffer.
		81
	1	82		FormattingHelpers.WriteTwoDecimalDigits((uint)offset.Minutes, buffer, 24);
	1	83		buffer[23] = Utf8Constants.Colon;
	1	84		FormattingHelpers.WriteTwoDecimalDigits((uint)offset.Hours, buffer, 21);
	1	85		buffer[20] = sign;
	1	86		buffer[19] = Utf8Constants.Space;
	1	87		}
		88
	1	89		return true;
	1	90		}
		91		}
		92		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Date.L.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Formatter
		8		{
		9		// Rfc1123 - lowercase
		10		//
		11		//   01234567890123456789012345678
		12		//   -----------------------------
		13		//   tue, 03 jan 2017 08:08:05 gmt
		14		//
		15		private static bool TryFormatDateTimeL(DateTime value, Span<byte> buffer, out int bytesWritten)
	1	16		{
		17		// Writing the check in this fashion elides all bounds checks on 'buffer'
		18		// for the remainder of the method.
	1	19		if ((uint)28 >= (uint)buffer.Length)
	1	20		{
	1	21		bytesWritten = 0;
	1	22		return false;
		23		}
		24
	1	25		var dayAbbrev = DayAbbreviationsLowercase[(int)value.DayOfWeek];
		26
	1	27		buffer[0] = (byte)dayAbbrev;
	1	28		dayAbbrev >>= 8;
	1	29		buffer[1] = (byte)dayAbbrev;
	1	30		dayAbbrev >>= 8;
	1	31		buffer[2] = (byte)dayAbbrev;
	1	32		buffer[3] = Utf8Constants.Comma;
	1	33		buffer[4] = Utf8Constants.Space;
		34
	1	35		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Day, buffer, 5);
	1	36		buffer[7] = Utf8Constants.Space;
		37
	1	38		var monthAbbrev = MonthAbbreviationsLowercase[value.Month - 1];
	1	39		buffer[8] = (byte)monthAbbrev;
	1	40		monthAbbrev >>= 8;
	1	41		buffer[9] = (byte)monthAbbrev;
	1	42		monthAbbrev >>= 8;
	1	43		buffer[10] = (byte)monthAbbrev;
	1	44		buffer[11] = Utf8Constants.Space;
		45
	1	46		FormattingHelpers.WriteFourDecimalDigits((uint)value.Year, buffer, 12);
	1	47		buffer[16] = Utf8Constants.Space;
		48
	1	49		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Hour, buffer, 17);
	1	50		buffer[19] = Utf8Constants.Colon;
		51
	1	52		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Minute, buffer, 20);
	1	53		buffer[22] = Utf8Constants.Colon;
		54
	1	55		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Second, buffer, 23);
	1	56		buffer[25] = Utf8Constants.Space;
		57
	1	58		buffer[26] = GMT1Lowercase;
	1	59		buffer[27] = GMT2Lowercase;
	1	60		buffer[28] = GMT3Lowercase;
		61
	1	62		bytesWritten = 29;
	1	63		return true;
	1	64		}
		65		}
		66		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Date.O.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Formatter
		8		{
		9		//
		10		// Roundtrippable format. One of
		11		//
		12		//   012345678901234567890123456789012
		13		//   ---------------------------------
		14		//   2017-06-12T05:30:45.7680000-07:00
		15		//   2017-06-12T05:30:45.7680000Z           (Z is short for "+00:00" but also distinguishes DateTimeKind.Utc fro
		16		//   2017-06-12T05:30:45.7680000            (interpreted as local time wrt to current time zone)
		17		//
		18		private static bool TryFormatDateTimeO(DateTime value, TimeSpan offset, Span<byte> buffer, out int bytesWritten)
	1	19		{
		20		const int MinimumBytesNeeded = 27;
		21
	1	22		int bytesRequired = MinimumBytesNeeded;
	1	23		DateTimeKind kind = DateTimeKind.Local;
		24
	1	25		if (offset == Utf8Constants.s_nullUtcOffset)
	1	26		{
	1	27		kind = value.Kind;
	1	28		if (kind == DateTimeKind.Local)
	1	29		{
	1	30		offset = TimeZoneInfo.Local.GetUtcOffset(value);
	1	31		bytesRequired += 6;
	1	32		}
	1	33		else if (kind == DateTimeKind.Utc)
	1	34		{
	1	35		bytesRequired += 1;
	1	36		}
	1	37		}
		38		else
	1	39		{
	1	40		bytesRequired += 6;
	1	41		}
		42
	1	43		if (buffer.Length < bytesRequired)
	1	44		{
	1	45		bytesWritten = 0;
	1	46		return false;
		47		}
		48
	1	49		bytesWritten = bytesRequired;
		50
		51		// Hoist most of the bounds checks on buffer.
	3	52		{ var unused = buffer[MinimumBytesNeeded - 1]; }
		53
	1	54		FormattingHelpers.WriteFourDecimalDigits((uint)value.Year, buffer, 0);
	1	55		buffer[4] = Utf8Constants.Minus;
		56
	1	57		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Month, buffer, 5);
	1	58		buffer[7] = Utf8Constants.Minus;
		59
	1	60		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Day, buffer, 8);
	1	61		buffer[10] = TimeMarker;
		62
	1	63		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Hour, buffer, 11);
	1	64		buffer[13] = Utf8Constants.Colon;
		65
	1	66		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Minute, buffer, 14);
	1	67		buffer[16] = Utf8Constants.Colon;
		68
	1	69		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Second, buffer, 17);
	1	70		buffer[19] = Utf8Constants.Period;
		71
	1	72		FormattingHelpers.WriteDigits((uint)((ulong)value.Ticks % (ulong)TimeSpan.TicksPerSecond), buffer.Slice(20,
		73
	1	74		if (kind == DateTimeKind.Local)
	1	75		{
		76		byte sign;
		77
	1	78		if (offset < default(TimeSpan) /* a "const" version of TimeSpan.Zero */)
	1	79		{
	1	80		sign = Utf8Constants.Minus;
	1	81		offset = TimeSpan.FromTicks(-offset.Ticks);
	1	82		}
		83		else
	1	84		{
	1	85		sign = Utf8Constants.Plus;
	1	86		}
		87
		88		// Writing the value backward allows the JIT to optimize by
		89		// performing a single bounds check against buffer.
		90
	1	91		FormattingHelpers.WriteTwoDecimalDigits((uint)offset.Minutes, buffer, 31);
	1	92		buffer[30] = Utf8Constants.Colon;
	1	93		FormattingHelpers.WriteTwoDecimalDigits((uint)offset.Hours, buffer, 28);
	1	94		buffer[27] = sign;
		95
	1	96		}
	1	97		else if (kind == DateTimeKind.Utc)
	1	98		{
	1	99		buffer[27] = UtcMarker;
	1	100		}
		101
	1	102		return true;
	1	103		}
		104		}
		105		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Date.R.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Formatter
		8		{
		9		// Rfc1123
		10		//
		11		//   01234567890123456789012345678
		12		//   -----------------------------
		13		//   Tue, 03 Jan 2017 08:08:05 GMT
		14		//
		15		private static bool TryFormatDateTimeR(DateTime value, Span<byte> buffer, out int bytesWritten)
	1	16		{
		17		// Writing the check in this fashion elides all bounds checks on 'buffer'
		18		// for the remainder of the method.
	1	19		if ((uint)28 >= (uint)buffer.Length)
	1	20		{
	1	21		bytesWritten = 0;
	1	22		return false;
		23		}
		24
	1	25		var dayAbbrev = DayAbbreviations[(int)value.DayOfWeek];
		26
	1	27		buffer[0] = (byte)dayAbbrev;
	1	28		dayAbbrev >>= 8;
	1	29		buffer[1] = (byte)dayAbbrev;
	1	30		dayAbbrev >>= 8;
	1	31		buffer[2] = (byte)dayAbbrev;
	1	32		buffer[3] = Utf8Constants.Comma;
	1	33		buffer[4] = Utf8Constants.Space;
		34
	1	35		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Day, buffer, 5);
	1	36		buffer[7] = Utf8Constants.Space;
		37
	1	38		var monthAbbrev = MonthAbbreviations[value.Month - 1];
	1	39		buffer[8] = (byte)monthAbbrev;
	1	40		monthAbbrev >>= 8;
	1	41		buffer[9] = (byte)monthAbbrev;
	1	42		monthAbbrev >>= 8;
	1	43		buffer[10] = (byte)monthAbbrev;
	1	44		buffer[11] = Utf8Constants.Space;
		45
	1	46		FormattingHelpers.WriteFourDecimalDigits((uint)value.Year, buffer, 12);
	1	47		buffer[16] = Utf8Constants.Space;
		48
	1	49		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Hour, buffer, 17);
	1	50		buffer[19] = Utf8Constants.Colon;
		51
	1	52		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Minute, buffer, 20);
	1	53		buffer[22] = Utf8Constants.Colon;
		54
	1	55		FormattingHelpers.WriteTwoDecimalDigits((uint)value.Second, buffer, 23);
	1	56		buffer[25] = Utf8Constants.Space;
		57
	1	58		buffer[26] = GMT1;
	1	59		buffer[27] = GMT2;
	1	60		buffer[28] = GMT3;
		61
	1	62		bytesWritten = 29;
	1	63		return true;
	1	64		}
		65		}
		66		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Decimal.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6
		7		namespace System.Buffers.Text
		8		{
		9		public static partial class Utf8Formatter
		10		{
		11		/// <summary>
		12		/// Formats a Decimal as a UTF8 string.
		13		/// </summary>
		14		/// <param name="value">Value to format</param>
		15		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		16		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		17		/// <param name="format">The standard format to use</param>
		18		/// <returns>
		19		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		20		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		21		/// </returns>
		22		/// <remarks>
		23		/// Formats supported:
		24		///     G/g  (default)
		25		///     F/f             12.45       Fixed point
		26		///     E/e             1.245000e1  Exponential
		27		/// </remarks>
		28		/// <exceptions>
		29		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		30		/// </exceptions>
		31		public static bool TryFormat(decimal value, Span<byte> buffer, out int bytesWritten, StandardFormat format = def
	1	32		{
	1	33		if (format.IsDefault)
	1	34		{
	1	35		format = 'G';
	1	36		}
		37
	1	38		switch (format.Symbol)
		39		{
		40		case 'g':
		41		case 'G':
	1	42		{
	1	43		if (format.Precision != StandardFormat.NoPrecision)
	1	44		throw new NotSupportedException(SR.Argument_GWithPrecisionNotSupported);
	1	45		NumberBuffer number = default;
	1	46		Number.DecimalToNumber(value, ref number);
	1	47		if (number.Digits[0] == 0)
	1	48		{
	1	49		number.IsNegative = false; // For Decimals, -0 must print as normal 0.
	1	50		}
	1	51		bool success = TryFormatDecimalG(ref number, buffer, out bytesWritten);
		52		#if DEBUG
		53		// This DEBUG segment exists to close a code coverage hole inside TryFormatDecimalG(). Because w
		54		// TryFormatDecimalG() a number where trailing zeros before the decimal point have been cropped.
		55		// ourselves and make a second call to ensure we get the same outcome.
	1	56		if (success)
	1	57		{
	1	58		Span<byte> digits = number.Digits;
	1	59		int numDigits = number.NumDigits;
	1	60		if (numDigits != 0 && number.Scale == numDigits && digits[numDigits - 1] == '0')
	1	61		{
	1	62		while (numDigits != 0 && digits[numDigits - 1] == '0')
	1	63		{
	1	64		digits[numDigits - 1] = 0;
	1	65		numDigits--;
	1	66		}
		67
	1	68		number.CheckConsistency();
		69
	1	70		byte[] buffer2 = new byte[buffer.Length];
	1	71		bool success2 = TryFormatDecimalG(ref number, buffer2, out int bytesWritten2);
	1	72		Debug.Assert(success2);
	1	73		Debug.Assert(bytesWritten2 == bytesWritten);
	3	74		for (int i = 0; i < bytesWritten; i++)
	1	75		{
	1	76		Debug.Assert(buffer[i] == buffer2[i]);
	1	77		}
	1	78		}
		79
	1	80		}
		81		#endif // DEBUG
	1	82		return success;
		83		}
		84
		85		case 'f':
		86		case 'F':
	1	87		{
	1	88		NumberBuffer number = default;
	1	89		Number.DecimalToNumber(value, ref number);
	1	90		byte precision = (format.Precision == StandardFormat.NoPrecision) ? (byte)2 : format.Precision;
	1	91		Number.RoundNumber(ref number, number.Scale + precision);
	1	92		Debug.Assert(!(number.Digits[0] == 0 && number.IsNegative));   // For Decimals, -0 must print as
	1	93		return TryFormatDecimalF(ref number, buffer, out bytesWritten, precision);
		94		}
		95
		96		case 'e':
		97		case 'E':
	1	98		{
	1	99		NumberBuffer number = default;
	1	100		Number.DecimalToNumber(value, ref number);
	1	101		byte precision = (format.Precision == StandardFormat.NoPrecision) ? (byte)6 : format.Precision;
	1	102		Number.RoundNumber(ref number, precision + 1);
	1	103		Debug.Assert(!(number.Digits[0] == 0 && number.IsNegative));   // For Decimals, -0 must print as
	1	104		return TryFormatDecimalE(ref number, buffer, out bytesWritten, precision, exponentSymbol: (byte)
		105		}
		106
		107		default:
	1	108		return ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
		109		}
	1	110		}
		111		}
		112		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Decimal.E.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6
		7		namespace System.Buffers.Text
		8		{
		9		public static partial class Utf8Formatter
		10		{
		11		private static bool TryFormatDecimalE(ref NumberBuffer number, Span<byte> buffer, out int bytesWritten, byte pre
	1	12		{
		13		const int NumExponentDigits = 3;
		14
	1	15		int scale = number.Scale;
	1	16		ReadOnlySpan<byte> digits = number.Digits;
		17
	1	18		int numBytesNeeded =
	1	19		((number.IsNegative) ? 1 : 0) // minus sign
	1	20		+ 1  // digits before the decimal point (exactly 1)
	1	21		+ ((precision == 0) ? 0 : (precision + 1)) // period and the digits after the decimal point
	1	22		+ 2  // 'E' or 'e' followed by '+' or '-'
	1	23		+ NumExponentDigits; // exponent digits
		24
	1	25		if (buffer.Length < numBytesNeeded)
	1	26		{
	1	27		bytesWritten = 0;
	1	28		return false;
		29		}
		30
	1	31		int dstIndex = 0;
	1	32		int srcIndex = 0;
	1	33		if (number.IsNegative)
	1	34		{
	1	35		buffer[dstIndex++] = Utf8Constants.Minus;
	1	36		}
		37
		38		//
		39		// Emit exactly one digit before the decimal point.
		40		//
		41		int exponent;
	1	42		byte firstDigit = digits[srcIndex];
	1	43		if (firstDigit == 0)
	1	44		{
	1	45		buffer[dstIndex++] = (byte)'0';  // Special case: number before the decimal point is exactly 0: Number d
	1	46		exponent = 0;
	1	47		}
		48		else
	1	49		{
	1	50		buffer[dstIndex++] = firstDigit;
	1	51		srcIndex++;
	1	52		exponent = scale - 1;
	1	53		}
		54
	1	55		if (precision > 0)
	1	56		{
	1	57		buffer[dstIndex++] = Utf8Constants.Period;
		58
		59		//
		60		// Emit digits after the decimal point.
		61		//
	1	62		int numDigitsEmitted = 0;
	1	63		while (numDigitsEmitted < precision)
	1	64		{
	1	65		byte digit = digits[srcIndex];
	1	66		if (digit == 0)
	1	67		{
	1	68		while (numDigitsEmitted++ < precision)
	1	69		{
	1	70		buffer[dstIndex++] = (byte)'0';
	1	71		}
	1	72		break;
		73		}
	1	74		buffer[dstIndex++] = digit;
	1	75		srcIndex++;
	1	76		numDigitsEmitted++;
	1	77		}
	1	78		}
		79
		80		// Emit the exponent symbol
	1	81		buffer[dstIndex++] = exponentSymbol;
	1	82		if (exponent >= 0)
	1	83		{
	1	84		buffer[dstIndex++] = Utf8Constants.Plus;
	1	85		}
		86		else
	1	87		{
	1	88		buffer[dstIndex++] = Utf8Constants.Minus;
	1	89		exponent = -exponent;
	1	90		}
		91
	1	92		Debug.Assert(exponent < Number.DECIMAL_PRECISION, "If you're trying to reuse this routine for double/float,
		93
		94		// Emit exactly three digits for the exponent.
	1	95		buffer[dstIndex++] = (byte)'0'; // The exponent for Decimal can never exceed 28 (let alone 99)
	1	96		buffer[dstIndex++] = (byte)((exponent / 10) + '0');
	1	97		buffer[dstIndex++] = (byte)((exponent % 10) + '0');
		98
	1	99		Debug.Assert(dstIndex == numBytesNeeded);
	1	100		bytesWritten = numBytesNeeded;
	1	101		return true;
	1	102		}
		103		}
		104		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Decimal.F.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6
		7		namespace System.Buffers.Text
		8		{
		9		public static partial class Utf8Formatter
		10		{
		11		private static bool TryFormatDecimalF(ref NumberBuffer number, Span<byte> buffer, out int bytesWritten, byte pre
	1	12		{
	1	13		int scale = number.Scale;
	1	14		ReadOnlySpan<byte> digits = number.Digits;
		15
	1	16		int numBytesNeeded =
	1	17		((number.IsNegative) ? 1 : 0) // minus sign
	1	18		+ ((scale <= 0) ? 1 : scale)  // digits before the decimal point (minimum 1)
	1	19		+ ((precision == 0) ? 0 : (precision + 1)); // if specified precision != 0, the decimal point and the di
		20
	1	21		if (buffer.Length < numBytesNeeded)
	1	22		{
	1	23		bytesWritten = 0;
	1	24		return false;
		25		}
		26
	1	27		int srcIndex = 0;
	1	28		int dstIndex = 0;
	1	29		if (number.IsNegative)
	1	30		{
	1	31		buffer[dstIndex++] = Utf8Constants.Minus;
	1	32		}
		33
		34		//
		35		// Emit digits before the decimal point.
		36		//
	1	37		if (scale <= 0)
	1	38		{
	1	39		buffer[dstIndex++] = (byte)'0';  // The integer portion is 0 and not stored. The formatter, however, nee
	1	40		}
		41		else
	1	42		{
	1	43		while (srcIndex < scale)
	1	44		{
	1	45		byte digit = digits[srcIndex];
	1	46		if (digit == 0)
	1	47		{
	1	48		int numTrailingZeroes = scale - srcIndex;
	3	49		for (int i = 0; i < numTrailingZeroes; i++)
	1	50		{
	1	51		buffer[dstIndex++] = (byte)'0';
	1	52		}
	1	53		break;
		54		}
		55
	1	56		buffer[dstIndex++] = digit;
	1	57		srcIndex++;
	1	58		}
	1	59		}
		60
	1	61		if (precision > 0)
	1	62		{
	1	63		buffer[dstIndex++] = Utf8Constants.Period;
		64
		65		//
		66		// Emit digits after the decimal point.
		67		//
	1	68		int numDigitsEmitted = 0;
	1	69		if (scale < 0)
	1	70		{
	1	71		int numLeadingZeroesToEmit = Math.Min((int)precision, -scale);
	3	72		for (int i = 0; i < numLeadingZeroesToEmit; i++)
	1	73		{
	1	74		buffer[dstIndex++] = (byte)'0';
	1	75		}
	1	76		numDigitsEmitted += numLeadingZeroesToEmit;
	1	77		}
		78
	1	79		while (numDigitsEmitted < precision)
	1	80		{
	1	81		byte digit = digits[srcIndex];
	1	82		if (digit == 0)
	1	83		{
	1	84		while (numDigitsEmitted++ < precision)
	1	85		{
	1	86		buffer[dstIndex++] = (byte)'0';
	1	87		}
	1	88		break;
		89		}
	1	90		buffer[dstIndex++] = digit;
	1	91		srcIndex++;
	1	92		numDigitsEmitted++;
	1	93		}
	1	94		}
		95
	1	96		Debug.Assert(dstIndex == numBytesNeeded);
	1	97		bytesWritten = numBytesNeeded;
	1	98		return true;
	1	99		}
		100		}
		101		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Decimal.G.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6		using System.Runtime.CompilerServices;
		7
		8		namespace System.Buffers.Text
		9		{
		10		public static partial class Utf8Formatter
		11		{
		12		private static bool TryFormatDecimalG(ref NumberBuffer number, Span<byte> buffer, out int bytesWritten)
	1	13		{
	1	14		int scale = number.Scale;
	1	15		ReadOnlySpan<byte> digits = number.Digits;
	1	16		int numDigits = number.NumDigits;
		17
	1	18		bool isFraction = scale < numDigits;
		19		int numBytesNeeded;
	1	20		if (isFraction)
	1	21		{
	1	22		numBytesNeeded = numDigits + 1;  // A fraction. Must include one for the decimal point.
	1	23		if (scale <= 0)
	1	24		{
	1	25		numBytesNeeded += 1 + (-scale); // A fraction of the form 0.ddd. Need to emit the non-stored 0 befor
	1	26		}
	1	27		}
		28		else
	1	29		{
	1	30		numBytesNeeded = ((scale <= 0) ? 1 : scale); // An integral. Just emit the digits before the decimal poi
	1	31		}
		32
	1	33		if (number.IsNegative)
	1	34		{
	1	35		numBytesNeeded++; // And the minus sign.
	1	36		}
		37
	1	38		if (buffer.Length < numBytesNeeded)
	1	39		{
	1	40		bytesWritten = 0;
	1	41		return false;
		42		}
		43
	1	44		int srcIndex = 0;
	1	45		int dstIndex = 0;
		46
	1	47		if (number.IsNegative)
	1	48		{
	1	49		buffer[dstIndex++] = Utf8Constants.Minus;
	1	50		}
		51
		52		//
		53		// Emit digits before the decimal point.
		54		//
	1	55		if (scale <= 0)
	1	56		{
	1	57		buffer[dstIndex++] = (byte)'0';  // The integer portion is 0 and not stored. The formatter, however, nee
	1	58		}
		59		else
	1	60		{
	1	61		while (srcIndex < scale)
	1	62		{
	1	63		byte digit = digits[srcIndex];
	1	64		if (digit == 0)
	1	65		{
	1	66		int numTrailingZeroes = scale - srcIndex;
	3	67		for (int i = 0; i < numTrailingZeroes; i++)
	1	68		{
	1	69		buffer[dstIndex++] = (byte)'0';
	1	70		}
	1	71		break;
		72		}
		73
	1	74		buffer[dstIndex++] = digit;
	1	75		srcIndex++;
	1	76		}
	1	77		}
		78
	1	79		if (isFraction)
	1	80		{
	1	81		buffer[dstIndex++] = Utf8Constants.Period;
		82
		83		//
		84		// Emit digits after the decimal point.
		85		//
	1	86		if (scale < 0)
	1	87		{
	1	88		int numLeadingZeroesToEmit = -scale;
	3	89		for (int i = 0; i < numLeadingZeroesToEmit; i++)
	1	90		{
	1	91		buffer[dstIndex++] = (byte)'0';
	1	92		}
	1	93		}
		94
		95		byte digit;
	1	96		while ((digit = digits[srcIndex++]) != 0)
	1	97		{
	1	98		buffer[dstIndex++] = digit;
	1	99		}
	1	100		}
		101
	1	102		Debug.Assert(dstIndex == numBytesNeeded);
		103
	1	104		bytesWritten = numBytesNeeded;
	1	105		return true;
	1	106		}
		107		}
		108		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Float.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6		using System.Globalization;
		7
		8		namespace System.Buffers.Text
		9		{
		10		public static partial class Utf8Formatter
		11		{
		12		/// <summary>
		13		/// Formats a Double as a UTF8 string.
		14		/// </summary>
		15		/// <param name="value">Value to format</param>
		16		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		17		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		18		/// <param name="format">The standard format to use</param>
		19		/// <returns>
		20		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		21		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		22		/// </returns>
		23		/// <remarks>
		24		/// Formats supported:
		25		///     G/g  (default)
		26		///     F/f             12.45       Fixed point
		27		///     E/e             1.245000e1  Exponential
		28		/// </remarks>
		29		/// <exceptions>
		30		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		31		/// </exceptions>
		32		public static bool TryFormat(double value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defa
	1	33		{
	1	34		return TryFormatFloatingPoint<double>(value, buffer, out bytesWritten, format);
	1	35		}
		36
		37		/// <summary>
		38		/// Formats a Single as a UTF8 string.
		39		/// </summary>
		40		/// <param name="value">Value to format</param>
		41		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		42		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		43		/// <param name="format">The standard format to use</param>
		44		/// <returns>
		45		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		46		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		47		/// </returns>
		48		/// <remarks>
		49		/// Formats supported:
		50		///     G/g  (default)
		51		///     F/f             12.45       Fixed point
		52		///     E/e             1.245000e1  Exponential
		53		/// </remarks>
		54		/// <exceptions>
		55		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		56		/// </exceptions>
		57		public static bool TryFormat(float value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defau
	1	58		{
	1	59		return TryFormatFloatingPoint<float>(value, buffer, out bytesWritten, format);
	1	60		}
		61
		62		//
		63		// Common handler for TryFormat(Double) and TryFormat(Single). You may notice that this particular routine isn't
		64		// of things. The DoubleToNumber() code is incredibly complex and is one of the few pieces of Number formatting
		65		// be preferable not to have another version of that lying around. Until we really hit a scenario where floating
		66		// make do with this.
		67		//
		68		private static bool TryFormatFloatingPoint<T>(T value, Span<byte> buffer, out int bytesWritten, StandardFormat f
	1	69		{
	1	70		if (format.IsDefault)
	1	71		{
	1	72		format = 'G';
	1	73		}
		74
	1	75		switch (format.Symbol)
		76		{
		77		case 'g':
		78		case 'G':
	1	79		if (format.Precision != StandardFormat.NoPrecision)
	1	80		throw new NotSupportedException(SR.Argument_GWithPrecisionNotSupported);
	1	81		break;
		82
		83		case 'f':
		84		case 'F':
		85		case 'e':
		86		case 'E':
	1	87		break;
		88
		89		default:
	1	90		return ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
		91		}
		92
	1	93		string formatString = format.ToString();
	1	94		string utf16Text = value.ToString(formatString, CultureInfo.InvariantCulture);
	1	95		int length = utf16Text.Length;
	1	96		if (length > buffer.Length)
	1	97		{
	1	98		bytesWritten = 0;
	1	99		return false;
		100		}
		101
	3	102		for (int i = 0; i < length; i++)
	1	103		{
	1	104		Debug.Assert(utf16Text[i] < 128, "A culture-invariant ToString() of a floating point expected to produce
	1	105		buffer[i] = (byte)(utf16Text[i]);
	1	106		}
		107
	1	108		bytesWritten = length;
	1	109		return true;
	1	110		}
		111		}
		112		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Guid.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Runtime.InteropServices;
		6
		7		namespace System.Buffers.Text
		8		{
		9		public static partial class Utf8Formatter
		10		{
		11		#region Constants
		12
		13		private const byte OpenBrace = (byte)'{';
		14		private const byte CloseBrace = (byte)'}';
		15
		16		private const byte OpenParen = (byte)'(';
		17		private const byte CloseParen = (byte)')';
		18
		19		private const byte Dash = (byte)'-';
		20
		21		#endregion Constants
		22
		23		/// <summary>
		24		/// Formats a Guid as a UTF8 string.
		25		/// </summary>
		26		/// <param name="value">Value to format</param>
		27		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		28		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		29		/// <param name="format">The standard format to use</param>
		30		/// <returns>
		31		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		32		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		33		/// </returns>
		34		/// <remarks>
		35		/// Formats supported:
		36		///     D (default)     nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnn
		37		///     B               {nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnn}
		38		///     P               (nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnn)
		39		///     N               nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
		40		/// </remarks>
		41		/// <exceptions>
		42		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		43		/// </exceptions>
		44		public static bool TryFormat(Guid value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defaul
	1	45		{
		46		const int INSERT_DASHES = unchecked((int)0x80000000);
		47		const int NO_DASHES = 0;
		48		const int INSERT_CURLY_BRACES = (CloseBrace << 16) | (OpenBrace << 8);
		49		const int INSERT_ROUND_BRACES = (CloseParen << 16) | (OpenParen << 8);
		50		const int NO_BRACES = 0;
		51		const int LEN_GUID_BASE = 32;
		52		const int LEN_ADD_DASHES = 4;
		53		const int LEN_ADD_BRACES = 2;
		54
		55		// This is a 32-bit value whose contents (where 0 is the low byte) are:
		56		// 0th byte: minimum required length of the output buffer,
		57		// 1st byte: the ASCII byte to insert for the opening brace position (or 0 if no braces),
		58		// 2nd byte: the ASCII byte to insert for the closing brace position (or 0 if no braces),
		59		// 3rd byte: high bit set if dashes are to be inserted.
		60		//
		61		// The reason for keeping a single flag instead of separate vars is that we can avoid register spillage
		62		// as we build up the output value.
		63		int flags;
		64
	1	65		switch (FormattingHelpers.GetSymbolOrDefault(format, 'D'))
		66		{
		67		case 'D': // nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnn
	1	68		flags = INSERT_DASHES + NO_BRACES + LEN_GUID_BASE + LEN_ADD_DASHES;
	1	69		break;
		70
		71		case 'B': // {nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnn}
	1	72		flags = INSERT_DASHES + INSERT_CURLY_BRACES + LEN_GUID_BASE + LEN_ADD_DASHES + LEN_ADD_BRACES;
	1	73		break;
		74
		75		case 'P': // (nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnn)
	1	76		flags = INSERT_DASHES + INSERT_ROUND_BRACES + LEN_GUID_BASE + LEN_ADD_DASHES + LEN_ADD_BRACES;
	1	77		break;
		78
		79		case 'N': // nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
	1	80		flags = NO_BRACES + NO_DASHES + LEN_GUID_BASE;
	1	81		break;
		82
		83		default:
	1	84		return ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
		85		}
		86
		87		// At this point, the low byte of flags contains the minimum required length
		88
	1	89		if ((byte)flags > buffer.Length)
	1	90		{
	1	91		bytesWritten = 0;
	1	92		return false;
		93		}
		94
	1	95		bytesWritten = (byte)flags;
	1	96		flags >>= 8;
		97
		98		// At this point, the low byte of flags contains the opening brace char (if any)
		99
	1	100		if ((byte)flags != 0)
	1	101		{
	1	102		buffer[0] = (byte)flags;
	1	103		buffer = buffer.Slice(1);
	1	104		}
	1	105		flags >>= 8;
		106
		107		// At this point, the low byte of flags contains the closing brace char (if any)
		108		// And since we're performing arithmetic shifting the high bit of flags is set (flags is negative) if dashes
		109
	1	110		DecomposedGuid guidAsBytes = default;
	1	111		guidAsBytes.Guid = value;
		112
		113		// When a GUID is blitted, the first three components are little-endian, and the last component is big-endia
		114
		115		// The line below forces the JIT to hoist the bounds check for the following segment.
		116		// The JIT will optimize away the read, but it cannot optimize away the bounds check
		117		// because it may have an observeable side effect (throwing).
		118		// We use 8 instead of 7 so that we also capture the dash if we're asked to insert one.
		119
	3	120		{ var unused = buffer[8]; }
	1	121		FormattingHelpers.WriteHexByte(guidAsBytes.Byte03, buffer, 0, FormattingHelpers.HexCasing.Lowercase);
	1	122		FormattingHelpers.WriteHexByte(guidAsBytes.Byte02, buffer, 2, FormattingHelpers.HexCasing.Lowercase);
	1	123		FormattingHelpers.WriteHexByte(guidAsBytes.Byte01, buffer, 4, FormattingHelpers.HexCasing.Lowercase);
	1	124		FormattingHelpers.WriteHexByte(guidAsBytes.Byte00, buffer, 6, FormattingHelpers.HexCasing.Lowercase);
		125
	1	126		if (flags < 0 /* use dash? */)
	1	127		{
	1	128		buffer[8] = Dash;
	1	129		buffer = buffer.Slice(9);
	1	130		}
		131		else
	1	132		{
	1	133		buffer = buffer.Slice(8);
	1	134		}
		135
	3	136		{ var unused = buffer[4]; }
	1	137		FormattingHelpers.WriteHexByte(guidAsBytes.Byte05, buffer, 0, FormattingHelpers.HexCasing.Lowercase);
	1	138		FormattingHelpers.WriteHexByte(guidAsBytes.Byte04, buffer, 2, FormattingHelpers.HexCasing.Lowercase);
		139
	1	140		if (flags < 0 /* use dash? */)
	1	141		{
	1	142		buffer[4] = Dash;
	1	143		buffer = buffer.Slice(5);
	1	144		}
		145		else
	1	146		{
	1	147		buffer = buffer.Slice(4);
	1	148		}
		149
	3	150		{ var unused = buffer[4]; }
	1	151		FormattingHelpers.WriteHexByte(guidAsBytes.Byte07, buffer, 0, FormattingHelpers.HexCasing.Lowercase);
	1	152		FormattingHelpers.WriteHexByte(guidAsBytes.Byte06, buffer, 2, FormattingHelpers.HexCasing.Lowercase);
		153
	1	154		if (flags < 0 /* use dash? */)
	1	155		{
	1	156		buffer[4] = Dash;
	1	157		buffer = buffer.Slice(5);
	1	158		}
		159		else
	1	160		{
	1	161		buffer = buffer.Slice(4);
	1	162		}
		163
	3	164		{ var unused = buffer[4]; }
	1	165		FormattingHelpers.WriteHexByte(guidAsBytes.Byte08, buffer, 0, FormattingHelpers.HexCasing.Lowercase);
	1	166		FormattingHelpers.WriteHexByte(guidAsBytes.Byte09, buffer, 2, FormattingHelpers.HexCasing.Lowercase);
		167
	1	168		if (flags < 0 /* use dash? */)
	1	169		{
	1	170		buffer[4] = Dash;
	1	171		buffer = buffer.Slice(5);
	1	172		}
		173		else
	1	174		{
	1	175		buffer = buffer.Slice(4);
	1	176		}
		177
	3	178		{ var unused = buffer[11]; } // can't hoist bounds check on the final brace (if exists)
	1	179		FormattingHelpers.WriteHexByte(guidAsBytes.Byte10, buffer, 0, FormattingHelpers.HexCasing.Lowercase);
	1	180		FormattingHelpers.WriteHexByte(guidAsBytes.Byte11, buffer, 2, FormattingHelpers.HexCasing.Lowercase);
	1	181		FormattingHelpers.WriteHexByte(guidAsBytes.Byte12, buffer, 4, FormattingHelpers.HexCasing.Lowercase);
	1	182		FormattingHelpers.WriteHexByte(guidAsBytes.Byte13, buffer, 6, FormattingHelpers.HexCasing.Lowercase);
	1	183		FormattingHelpers.WriteHexByte(guidAsBytes.Byte14, buffer, 8, FormattingHelpers.HexCasing.Lowercase);
	1	184		FormattingHelpers.WriteHexByte(guidAsBytes.Byte15, buffer, 10, FormattingHelpers.HexCasing.Lowercase);
		185
	1	186		if ((byte)flags != 0)
	1	187		{
	1	188		buffer[12] = (byte)flags;
	1	189		}
		190
	1	191		return true;
	1	192		}
		193
		194		/// <summary>
		195		/// Used to provide access to the individual bytes of a GUID.
		196		/// </summary>
		197		[StructLayout(LayoutKind.Explicit)]
		198		private struct DecomposedGuid
		199		{
		200		[FieldOffset(00)] public Guid Guid;
		201		[FieldOffset(00)] public byte Byte00;
		202		[FieldOffset(01)] public byte Byte01;
		203		[FieldOffset(02)] public byte Byte02;
		204		[FieldOffset(03)] public byte Byte03;
		205		[FieldOffset(04)] public byte Byte04;
		206		[FieldOffset(05)] public byte Byte05;
		207		[FieldOffset(06)] public byte Byte06;
		208		[FieldOffset(07)] public byte Byte07;
		209		[FieldOffset(08)] public byte Byte08;
		210		[FieldOffset(09)] public byte Byte09;
		211		[FieldOffset(10)] public byte Byte10;
		212		[FieldOffset(11)] public byte Byte11;
		213		[FieldOffset(12)] public byte Byte12;
		214		[FieldOffset(13)] public byte Byte13;
		215		[FieldOffset(14)] public byte Byte14;
		216		[FieldOffset(15)] public byte Byte15;
		217		}
		218		}
		219		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		namespace System.Buffers.Text
		6		{
		7		/// <summary>
		8		/// Methods to format common data types as Utf8 strings.
		9		/// </summary>
		10		public static partial class Utf8Formatter
		11		{
		12		/// <summary>
		13		/// Formats a Byte as a UTF8 string.
		14		/// </summary>
		15		/// <param name="value">Value to format</param>
		16		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		17		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		18		/// <param name="format">The standard format to use</param>
		19		/// <returns>
		20		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		21		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		22		/// </returns>
		23		/// <remarks>
		24		/// Formats supported:
		25		///     G/g (default)
		26		///     D/d             32767
		27		///     N/n             32,767
		28		///     X/x             7fff
		29		/// </remarks>
		30		/// <exceptions>
		31		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		32		/// </exceptions>
		33		public static bool TryFormat(byte value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defaul
	1	34		=> TryFormatUInt64(value, buffer, out bytesWritten, format);
		35
		36		/// <summary>
		37		/// Formats an SByte as a UTF8 string.
		38		/// </summary>
		39		/// <param name="value">Value to format</param>
		40		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		41		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		42		/// <param name="format">The standard format to use</param>
		43		/// <returns>
		44		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		45		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		46		/// </returns>
		47		/// <remarks>
		48		/// Formats supported:
		49		///     G/g (default)
		50		///     D/d             32767
		51		///     N/n             32,767
		52		///     X/x             7fff
		53		/// </remarks>
		54		/// <exceptions>
		55		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		56		/// </exceptions>
		57		[CLSCompliant(false)]
		58		public static bool TryFormat(sbyte value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defau
	1	59		=> TryFormatInt64(value, 0xff, buffer, out bytesWritten, format);
		60
		61		/// <summary>
		62		/// Formats a Unt16 as a UTF8 string.
		63		/// </summary>
		64		/// <param name="value">Value to format</param>
		65		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		66		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		67		/// <param name="format">The standard format to use</param>
		68		/// <returns>
		69		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		70		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		71		/// </returns>
		72		/// <remarks>
		73		/// Formats supported:
		74		///     G/g (default)
		75		///     D/d             32767
		76		///     N/n             32,767
		77		///     X/x             7fff
		78		/// </remarks>
		79		/// <exceptions>
		80		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		81		/// </exceptions>
		82		[CLSCompliant(false)]
		83		public static bool TryFormat(ushort value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defa
	1	84		=> TryFormatUInt64(value, buffer, out bytesWritten, format);
		85
		86		/// <summary>
		87		/// Formats an Int16 as a UTF8 string.
		88		/// </summary>
		89		/// <param name="value">Value to format</param>
		90		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		91		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		92		/// <param name="format">The standard format to use</param>
		93		/// <returns>
		94		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		95		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		96		/// </returns>
		97		/// <remarks>
		98		/// Formats supported:
		99		///     G/g (default)
		100		///     D/d             32767
		101		///     N/n             32,767
		102		///     X/x             7fff
		103		/// </remarks>
		104		/// <exceptions>
		105		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		106		/// </exceptions>
		107		public static bool TryFormat(short value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defau
	1	108		=> TryFormatInt64(value, 0xffff, buffer, out bytesWritten, format);
		109
		110		/// <summary>
		111		/// Formats a UInt32 as a UTF8 string.
		112		/// </summary>
		113		/// <param name="value">Value to format</param>
		114		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		115		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		116		/// <param name="format">The standard format to use</param>
		117		/// <returns>
		118		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		119		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		120		/// </returns>
		121		/// <remarks>
		122		/// Formats supported:
		123		///     G/g (default)
		124		///     D/d             32767
		125		///     N/n             32,767
		126		///     X/x             7fff
		127		/// </remarks>
		128		/// <exceptions>
		129		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		130		/// </exceptions>
		131		[CLSCompliant(false)]
		132		public static bool TryFormat(uint value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defaul
	1	133		=> TryFormatUInt64(value, buffer, out bytesWritten, format);
		134
		135		/// <summary>
		136		/// Formats an Int32 as a UTF8 string.
		137		/// </summary>
		138		/// <param name="value">Value to format</param>
		139		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		140		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		141		/// <param name="format">The standard format to use</param>
		142		/// <returns>
		143		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		144		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		145		/// </returns>
		146		/// <remarks>
		147		/// Formats supported:
		148		///     G/g (default)
		149		///     D/d             32767
		150		///     N/n             32,767
		151		///     X/x             7fff
		152		/// </remarks>
		153		/// <exceptions>
		154		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		155		/// </exceptions>
		156		public static bool TryFormat(int value, Span<byte> buffer, out int bytesWritten, StandardFormat format = default
	1	157		=> TryFormatInt64(value, 0xffffffff, buffer, out bytesWritten, format);
		158
		159		/// <summary>
		160		/// Formats a UInt64 as a UTF8 string.
		161		/// </summary>
		162		/// <param name="value">Value to format</param>
		163		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		164		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		165		/// <param name="format">The standard format to use</param>
		166		/// <returns>
		167		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		168		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		169		/// </returns>
		170		/// <remarks>
		171		/// Formats supported:
		172		///     G/g (default)
		173		///     D/d             32767
		174		///     N/n             32,767
		175		///     X/x             7fff
		176		/// </remarks>
		177		/// <exceptions>
		178		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		179		/// </exceptions>
		180		[CLSCompliant(false)]
		181		public static bool TryFormat(ulong value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defau
	1	182		=> TryFormatUInt64(value, buffer, out bytesWritten, format);
		183
		184		/// <summary>
		185		/// Formats an Int64 as a UTF8 string.
		186		/// </summary>
		187		/// <param name="value">Value to format</param>
		188		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		189		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		190		/// <param name="format">The standard format to use</param>
		191		/// <returns>
		192		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		193		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		194		/// </returns>
		195		/// <remarks>
		196		/// Formats supported:
		197		///     G/g (default)
		198		///     D/d             32767
		199		///     N/n             32,767
		200		///     X/x             7fff
		201		/// </remarks>
		202		/// <exceptions>
		203		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		204		/// </exceptions>
		205		public static bool TryFormat(long value, Span<byte> buffer, out int bytesWritten, StandardFormat format = defaul
	1	206		=> TryFormatInt64(value, 0xffffffffffffffff, buffer, out bytesWritten, format);
		207		}
		208		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Signed.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Runtime.CompilerServices;
		6
		7		namespace System.Buffers.Text
		8		{
		9		/// <summary>
		10		/// Methods to format common data types as Utf8 strings.
		11		/// </summary>
		12		public static partial class Utf8Formatter
		13		{
		14		//
		15		// Common worker for all signed integer TryFormat overloads
		16		//
		17		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		18		private static bool TryFormatInt64(long value, ulong mask, Span<byte> buffer, out int bytesWritten, StandardForm
	1	19		{
	1	20		if (format.IsDefault)
	1	21		{
	1	22		return TryFormatInt64Default(value, buffer, out bytesWritten);
		23		}
		24
	1	25		switch (format.Symbol)
		26		{
		27		case 'G':
		28		case 'g':
	1	29		if (format.HasPrecision)
	1	30		throw new NotSupportedException(SR.Argument_GWithPrecisionNotSupported); // With a precision, 'G
	1	31		return TryFormatInt64D(value, format.Precision, buffer, out bytesWritten);
		32
		33		case 'd':
		34		case 'D':
	1	35		return TryFormatInt64D(value, format.Precision, buffer, out bytesWritten);
		36
		37		case 'n':
		38		case 'N':
	1	39		return TryFormatInt64N(value, format.Precision, buffer, out bytesWritten);
		40
		41		case 'x':
	1	42		return TryFormatUInt64X((ulong)value & mask, format.Precision, true, buffer, out bytesWritten);
		43
		44		case 'X':
	1	45		return TryFormatUInt64X((ulong)value & mask, format.Precision, false, buffer, out bytesWritten);
		46
		47		default:
	1	48		return ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
		49		}
	1	50		}
		51		}
		52		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Signed.D.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6		using System.Runtime.CompilerServices;
		7
		8		namespace System.Buffers.Text
		9		{
		10		/// <summary>
		11		/// Methods to format common data types as Utf8 strings.
		12		/// </summary>
		13		public static partial class Utf8Formatter
		14		{
		15		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		16		private static bool TryFormatInt64D(long value, byte precision, Span<byte> buffer, out int bytesWritten)
	1	17		{
	1	18		bool insertNegationSign = false;
	1	19		if (value < 0)
	1	20		{
	1	21		insertNegationSign = true;
	1	22		value = -value;
	1	23		if (value < 0)
	1	24		{
	1	25		Debug.Assert(value == Int64.MinValue);
	1	26		return TryFormatInt64D_MinValue(precision, buffer, out bytesWritten);
		27		}
	1	28		}
		29
	1	30		return TryFormatUInt64D((ulong)value, precision, buffer, insertNegationSign, out bytesWritten);
	1	31		}
		32
		33		[MethodImpl(MethodImplOptions.NoInlining)]
		34		private static bool TryFormatInt64D_MinValue(byte precision, Span<byte> buffer, out int bytesWritten)
	1	35		{
		36		// Int64.MinValue must be treated specially since its two's complement negation doesn't fit into 64 bits.
		37		// Instead, we'll perform one's complement negation and fix up the +1 later (-x := ~x + 1).
		38		// Int64.MinValue = -9,223,372,036,854,775,808
		39		// Int64.MaxValue =  9,223,372,036,854,775,807
		40
	1	41		bool retVal = TryFormatUInt64D((ulong)Int64.MaxValue, precision, buffer, insertNegationSign: true, out int t
	1	42		if (retVal)
	1	43		{
	1	44		buffer[tempBytesWritten - 1]++; // bump the last ASCII '7' to an '8'
	1	45		}
		46
	1	47		bytesWritten = tempBytesWritten;
	1	48		return retVal;
	1	49		}
		50		}
		51		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Signed.Default.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6		using System.Runtime.CompilerServices;
		7
		8		namespace System.Buffers.Text
		9		{
		10		/// <summary>
		11		/// Methods to format common data types as Utf8 strings.
		12		/// </summary>
		13		public static partial class Utf8Formatter
		14		{
		15		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		16		private static bool TryFormatInt64Default(long value, Span<byte> buffer, out int bytesWritten)
	1	17		{
	1	18		if ((ulong)value < 10)
	1	19		{
	1	20		return TryFormatUInt32SingleDigit((uint)value, buffer, out bytesWritten);
		21		}
		22
	1	23		if (IntPtr.Size == 8)    // x64
	1	24		{
	1	25		return TryFormatInt64MultipleDigits(value, buffer, out bytesWritten);
		26		}
		27		else    // x86
	0	28		{
	0	29		if (value <= int.MaxValue && value >= int.MinValue)
	0	30		{
	0	31		return TryFormatInt32MultipleDigits((int)value, buffer, out bytesWritten);
		32		}
		33		else
	0	34		{
	0	35		if (value <= (long)Utf8Constants.BillionMaxUIntValue && value >= -(long)Utf8Constants.BillionMaxUInt
	0	36		{
	0	37		return value < 0 ?
	0	38		TryFormatInt64MoreThanNegativeBillionMaxUInt(-value, buffer, out bytesWritten) :
	0	39		TryFormatUInt64LessThanBillionMaxUInt((ulong)value, buffer, out bytesWritten);
		40		}
		41		else
	0	42		{
	0	43		return value < 0 ?
	0	44		TryFormatInt64LessThanNegativeBillionMaxUInt(-value, buffer, out bytesWritten) :
	0	45		TryFormatUInt64MoreThanBillionMaxUInt((ulong)value, buffer, out bytesWritten);
		46		}
		47		}
		48		}
	1	49		}
		50
		51		// TODO: Use this instead of TryFormatInt64Default to format numbers less than int.MaxValue
		52		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		53		private static bool TryFormatInt32Default(int value, Span<byte> buffer, out int bytesWritten)
		54		{
		55		if ((uint)value < 10)
		56		{
		57		return TryFormatUInt32SingleDigit((uint)value, buffer, out bytesWritten);
		58		}
		59		return TryFormatInt32MultipleDigits(value, buffer, out bytesWritten);
		60		}
		61
		62		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		63		private static bool TryFormatInt32MultipleDigits(int value, Span<byte> buffer, out int bytesWritten)
	0	64		{
	0	65		if (value < 0)
	0	66		{
	0	67		value = -value;
	0	68		int digitCount = FormattingHelpers.CountDigits((uint)value);
		69		// WriteDigits does not do bounds checks
	0	70		if (digitCount >= buffer.Length)
	0	71		{
	0	72		bytesWritten = 0;
	0	73		return false;
		74		}
	0	75		buffer[0] = Utf8Constants.Minus;
	0	76		bytesWritten = digitCount + 1;
	0	77		FormattingHelpers.WriteDigits((uint)value, buffer.Slice(1, digitCount));
	0	78		return true;
		79		}
		80		else
	0	81		{
	0	82		return TryFormatUInt32MultipleDigits((uint)value, buffer, out bytesWritten);
		83		}
	0	84		}
		85
		86		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		87		private static bool TryFormatInt64MultipleDigits(long value, Span<byte> buffer, out int bytesWritten)
	1	88		{
	1	89		if (value < 0)
	1	90		{
	1	91		value = -value;
	1	92		int digitCount = FormattingHelpers.CountDigits((ulong)value);
		93		// WriteDigits does not do bounds checks
	1	94		if (digitCount >= buffer.Length)
	1	95		{
	1	96		bytesWritten = 0;
	1	97		return false;
		98		}
	1	99		buffer[0] = Utf8Constants.Minus;
	1	100		bytesWritten = digitCount + 1;
	1	101		FormattingHelpers.WriteDigits((ulong)value, buffer.Slice(1, digitCount));
	1	102		return true;
		103		}
		104		else
	1	105		{
	1	106		return TryFormatUInt64MultipleDigits((ulong)value, buffer, out bytesWritten);
		107		}
	1	108		}
		109
		110		// Split long into two parts that can each fit in a uint - {1-10 digits}{9 digits}
		111		private static bool TryFormatInt64MoreThanNegativeBillionMaxUInt(long value, Span<byte> buffer, out int bytesWri
	0	112		{
	0	113		uint overNineDigits = (uint)(value / Utf8Constants.Billion);
	0	114		uint lastNineDigits = (uint)(value - (overNineDigits * Utf8Constants.Billion));
		115
	0	116		int digitCountOverNineDigits = FormattingHelpers.CountDigits(overNineDigits);
	0	117		Debug.Assert(digitCountOverNineDigits >= 1 && digitCountOverNineDigits <= 10);
	0	118		int digitCount = digitCountOverNineDigits + 9;
		119		// WriteDigits does not do bounds checks
	0	120		if (digitCount >= buffer.Length)
	0	121		{
	0	122		bytesWritten = 0;
	0	123		return false;
		124		}
	0	125		buffer[0] = Utf8Constants.Minus;
	0	126		bytesWritten = digitCount + 1;
	0	127		FormattingHelpers.WriteDigits(overNineDigits, buffer.Slice(1, digitCountOverNineDigits));
	0	128		FormattingHelpers.WriteDigits(lastNineDigits, buffer.Slice(digitCountOverNineDigits + 1, 9));
	0	129		return true;
	0	130		}
		131
		132		// Split long into three parts that can each fit in a uint - {1 digit}{9 digits}{9 digits}
		133		private static bool TryFormatInt64LessThanNegativeBillionMaxUInt(long value, Span<byte> buffer, out int bytesWri
	0	134		{
		135		// value can still be negative if value == long.MinValue
		136		// Therefore, cast to ulong, since (ulong)value actually equals abs(long.MinValue)
	0	137		ulong overNineDigits = (ulong)value / Utf8Constants.Billion;
	0	138		uint lastNineDigits = (uint)((ulong)value - (overNineDigits * Utf8Constants.Billion));
	0	139		uint overEighteenDigits = (uint)(overNineDigits / Utf8Constants.Billion);
	0	140		uint middleNineDigits = (uint)(overNineDigits - (overEighteenDigits * Utf8Constants.Billion));
		141
	0	142		int digitCountOverEighteenDigits = FormattingHelpers.CountDigits(overEighteenDigits);
	0	143		Debug.Assert(digitCountOverEighteenDigits == 1);
	0	144		int digitCount = digitCountOverEighteenDigits + 18;
		145		// WriteDigits does not do bounds checks
	0	146		if (digitCount >= buffer.Length)
	0	147		{
	0	148		bytesWritten = 0;
	0	149		return false;
		150		}
	0	151		buffer[0] = Utf8Constants.Minus;
	0	152		bytesWritten = digitCount + 1;
	0	153		FormattingHelpers.WriteDigits(overEighteenDigits, buffer.Slice(1, digitCountOverEighteenDigits));
	0	154		FormattingHelpers.WriteDigits(middleNineDigits, buffer.Slice(digitCountOverEighteenDigits + 1, 9));
	0	155		FormattingHelpers.WriteDigits(lastNineDigits, buffer.Slice(digitCountOverEighteenDigits + 1 + 9, 9));
	0	156		return true;
	0	157		}
		158		}
		159		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Signed.N.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6		using System.Runtime.CompilerServices;
		7
		8		namespace System.Buffers.Text
		9		{
		10		/// <summary>
		11		/// Methods to format common data types as Utf8 strings.
		12		/// </summary>
		13		public static partial class Utf8Formatter
		14		{
		15		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		16		private static bool TryFormatInt64N(long value, byte precision, Span<byte> buffer, out int bytesWritten)
	1	17		{
	1	18		bool insertNegationSign = false;
	1	19		if (value < 0)
	1	20		{
	1	21		insertNegationSign = true;
	1	22		value = -value;
	1	23		if (value < 0)
	1	24		{
	1	25		Debug.Assert(value == Int64.MinValue);
	1	26		return TryFormatInt64N_MinValue(precision, buffer, out bytesWritten);
		27		}
	1	28		}
		29
	1	30		return TryFormatUInt64N((ulong)value, precision, buffer, insertNegationSign, out bytesWritten);
	1	31		}
		32
		33		[MethodImpl(MethodImplOptions.NoInlining)]
		34		private static bool TryFormatInt64N_MinValue(byte precision, Span<byte> buffer, out int bytesWritten)
	1	35		{
		36		// Int64.MinValue must be treated specially since its two's complement negation doesn't fit into 64 bits.
		37		// Instead, we'll perform one's complement negation and fix up the +1 later (-x := ~x + 1).
		38		// Int64.MinValue = -9,223,372,036,854,775,808 (26 digits, including minus and commas)
		39		// Int64.MaxValue =  9,223,372,036,854,775,807
		40
	1	41		bool retVal = TryFormatUInt64N((ulong)Int64.MaxValue, precision, buffer, insertNegationSign: true, out int t
	1	42		if (retVal)
	1	43		{
	1	44		buffer[25]++; // bump the last ASCII '7' to an '8'
	1	45		}
		46
	1	47		bytesWritten = tempBytesWritten;
	1	48		return retVal;
	1	49		}
		50		}
		51		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Unsigned.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Runtime.CompilerServices;
		6
		7		namespace System.Buffers.Text
		8		{
		9		/// <summary>
		10		/// Methods to format common data types as Utf8 strings.
		11		/// </summary>
		12		public static partial class Utf8Formatter
		13		{
		14		//
		15		// Common worker for all unsigned integer TryFormat overloads
		16		//
		17		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		18		private static bool TryFormatUInt64(ulong value, Span<byte> buffer, out int bytesWritten, StandardFormat format)
	1	19		{
	1	20		if (format.IsDefault)
	1	21		{
	1	22		return TryFormatUInt64Default(value, buffer, out bytesWritten);
		23		}
		24
	1	25		switch (format.Symbol)
		26		{
		27		case 'G':
		28		case 'g':
	1	29		if (format.HasPrecision)
	1	30		throw new NotSupportedException(SR.Argument_GWithPrecisionNotSupported); // With a precision, 'G
	1	31		return TryFormatUInt64D(value, format.Precision, buffer, insertNegationSign: false, out bytesWritten
		32
		33		case 'd':
		34		case 'D':
	1	35		return TryFormatUInt64D(value, format.Precision, buffer, insertNegationSign: false, out bytesWritten
		36
		37		case 'n':
		38		case 'N':
	1	39		return TryFormatUInt64N(value, format.Precision, buffer, insertNegationSign: false, out bytesWritten
		40
		41		case 'x':
	1	42		return TryFormatUInt64X(value, format.Precision, true /* useLower */, buffer, out bytesWritten);
		43
		44		case 'X':
	1	45		return TryFormatUInt64X(value, format.Precision, false /* useLower */, buffer, out bytesWritten);
		46
		47		default:
	1	48		return ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
		49		}
	1	50		}
		51		}
		52		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Unsigned.D.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		namespace System.Buffers.Text
		6		{
		7		/// <summary>
		8		/// Methods to format common data types as Utf8 strings.
		9		/// </summary>
		10		public static partial class Utf8Formatter
		11		{
		12		private static bool TryFormatUInt64D(ulong value, byte precision, Span<byte> buffer, bool insertNegationSign, ou
	1	13		{
		14		// Calculate the actual digit count and the number of padding zeroes requested.
		15		// From all of this we can get the required buffer length.
		16
	1	17		int digitCount = FormattingHelpers.CountDigits(value);
	1	18		int leadingZeroCount = ((precision == StandardFormat.NoPrecision) ? 0 : (int)precision) - digitCount;
	1	19		if (leadingZeroCount < 0)
	1	20		{
	1	21		leadingZeroCount = 0;
	1	22		}
		23
	1	24		int requiredBufferLength = digitCount + leadingZeroCount;
		25
	1	26		if (insertNegationSign)
	1	27		{
	1	28		requiredBufferLength++;
	1	29		}
		30
	1	31		if (requiredBufferLength > buffer.Length)
	1	32		{
	1	33		bytesWritten = 0;
	1	34		return false;
		35		}
		36
	1	37		bytesWritten = requiredBufferLength;
		38
	1	39		if (insertNegationSign)
	1	40		{
	1	41		buffer[0] = Utf8Constants.Minus;
	1	42		buffer = buffer.Slice(1);
	1	43		}
		44
	1	45		if (leadingZeroCount > 0)
	1	46		{
	1	47		FormattingHelpers.FillWithAsciiZeros(buffer.Slice(0, leadingZeroCount));
	1	48		}
	1	49		FormattingHelpers.WriteDigits(value, buffer.Slice(leadingZeroCount, digitCount));
		50
	1	51		return true;
	1	52		}
		53		}
		54		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Unsigned.Default.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6		using System.Runtime.CompilerServices;
		7
		8		namespace System.Buffers.Text
		9		{
		10		/// <summary>
		11		/// Methods to format common data types as Utf8 strings.
		12		/// </summary>
		13		public static partial class Utf8Formatter
		14		{
		15		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		16		private static bool TryFormatUInt64Default(ulong value, Span<byte> buffer, out int bytesWritten)
	1	17		{
	1	18		if (value < 10)
	1	19		{
	1	20		return TryFormatUInt32SingleDigit((uint)value, buffer, out bytesWritten);
		21		}
		22
	1	23		if (IntPtr.Size == 8)    // x64
	1	24		{
	1	25		return TryFormatUInt64MultipleDigits(value, buffer, out bytesWritten);
		26		}
		27		else    // x86
	0	28		{
	0	29		if (value <= uint.MaxValue)
	0	30		{
	0	31		return TryFormatUInt32MultipleDigits((uint)value, buffer, out bytesWritten);
		32		}
		33		else
	0	34		{
	0	35		if (value <= Utf8Constants.BillionMaxUIntValue)
	0	36		{
	0	37		return TryFormatUInt64LessThanBillionMaxUInt(value, buffer, out bytesWritten);
		38		}
		39		else
	0	40		{
	0	41		return TryFormatUInt64MoreThanBillionMaxUInt(value, buffer, out bytesWritten);
		42		}
		43		}
		44		}
	1	45		}
		46
		47		// TODO: Use this instead of TryFormatUInt64Default to format numbers less than uint.MaxValue
		48		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		49		private static bool TryFormatUInt32Default(uint value, Span<byte> buffer, out int bytesWritten)
		50		{
		51		if (value < 10)
		52		{
		53		return TryFormatUInt32SingleDigit(value, buffer, out bytesWritten);
		54		}
		55		return TryFormatUInt32MultipleDigits(value, buffer, out bytesWritten);
		56		}
		57
		58		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		59		private static bool TryFormatUInt32SingleDigit(uint value, Span<byte> buffer, out int bytesWritten)
	1	60		{
	1	61		if (buffer.Length == 0)
	1	62		{
	1	63		bytesWritten = 0;
	1	64		return false;
		65		}
	1	66		buffer[0] = (byte)('0' + value);
	1	67		bytesWritten = 1;
	1	68		return true;
	1	69		}
		70
		71		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		72		private static bool TryFormatUInt32MultipleDigits(uint value, Span<byte> buffer, out int bytesWritten)
	0	73		{
	0	74		int digitCount = FormattingHelpers.CountDigits(value);
		75		// WriteDigits does not do bounds checks
	0	76		if (digitCount > buffer.Length)
	0	77		{
	0	78		bytesWritten = 0;
	0	79		return false;
		80		}
	0	81		bytesWritten = digitCount;
	0	82		FormattingHelpers.WriteDigits(value, buffer.Slice(0, digitCount));
	0	83		return true;
	0	84		}
		85
		86		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		87		private static bool TryFormatUInt64SingleDigit(ulong value, Span<byte> buffer, out int bytesWritten)
		88		{
		89		if (buffer.Length == 0)
		90		{
		91		bytesWritten = 0;
		92		return false;
		93		}
		94		buffer[0] = (byte)('0' + value);
		95		bytesWritten = 1;
		96		return true;
		97		}
		98
		99		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		100		private static bool TryFormatUInt64MultipleDigits(ulong value, Span<byte> buffer, out int bytesWritten)
	1	101		{
	1	102		int digitCount = FormattingHelpers.CountDigits(value);
		103		// WriteDigits does not do bounds checks
	1	104		if (digitCount > buffer.Length)
	1	105		{
	1	106		bytesWritten = 0;
	1	107		return false;
		108		}
	1	109		bytesWritten = digitCount;
	1	110		FormattingHelpers.WriteDigits(value, buffer.Slice(0, digitCount));
	1	111		return true;
	1	112		}
		113
		114		// Split ulong into two parts that can each fit in a uint - {1-10 digits}{9 digits}
		115		private static bool TryFormatUInt64LessThanBillionMaxUInt(ulong value, Span<byte> buffer, out int bytesWritten)
	0	116		{
	0	117		uint overNineDigits = (uint)(value / Utf8Constants.Billion);
	0	118		uint lastNineDigits = (uint)(value - (overNineDigits * Utf8Constants.Billion));
		119
	0	120		int digitCountOverNineDigits = FormattingHelpers.CountDigits(overNineDigits);
	0	121		Debug.Assert(digitCountOverNineDigits >= 1 && digitCountOverNineDigits <= 10);
	0	122		int digitCount = digitCountOverNineDigits + 9;
		123		// WriteDigits does not do bounds checks
	0	124		if (digitCount > buffer.Length)
	0	125		{
	0	126		bytesWritten = 0;
	0	127		return false;
		128		}
	0	129		bytesWritten = digitCount;
	0	130		FormattingHelpers.WriteDigits(overNineDigits, buffer.Slice(0, digitCountOverNineDigits));
	0	131		FormattingHelpers.WriteDigits(lastNineDigits, buffer.Slice(digitCountOverNineDigits, 9));
	0	132		return true;
	0	133		}
		134
		135		// Split ulong into three parts that can each fit in a uint - {1-2 digits}{9 digits}{9 digits}
		136		private static bool TryFormatUInt64MoreThanBillionMaxUInt(ulong value, Span<byte> buffer, out int bytesWritten)
	0	137		{
	0	138		ulong overNineDigits = value / Utf8Constants.Billion;
	0	139		uint lastNineDigits = (uint)(value - (overNineDigits * Utf8Constants.Billion));
	0	140		uint overEighteenDigits = (uint)(overNineDigits / Utf8Constants.Billion);
	0	141		uint middleNineDigits = (uint)(overNineDigits - (overEighteenDigits * Utf8Constants.Billion));
		142
	0	143		int digitCountOverEighteenDigits = FormattingHelpers.CountDigits(overEighteenDigits);
	0	144		Debug.Assert(digitCountOverEighteenDigits >= 1 && digitCountOverEighteenDigits <= 2);
	0	145		int digitCount = digitCountOverEighteenDigits + 18;
		146		// WriteDigits does not do bounds checks
	0	147		if (digitCount > buffer.Length)
	0	148		{
	0	149		bytesWritten = 0;
	0	150		return false;
		151		}
	0	152		bytesWritten = digitCount;
	0	153		FormattingHelpers.WriteDigits(overEighteenDigits, buffer.Slice(0, digitCountOverEighteenDigits));
	0	154		FormattingHelpers.WriteDigits(middleNineDigits, buffer.Slice(digitCountOverEighteenDigits, 9));
	0	155		FormattingHelpers.WriteDigits(lastNineDigits, buffer.Slice(digitCountOverEighteenDigits + 9, 9));
	0	156		return true;
	0	157		}
		158		}
		159		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Unsigned.N.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		namespace System.Buffers.Text
		6		{
		7		/// <summary>
		8		/// Methods to format common data types as Utf8 strings.
		9		/// </summary>
		10		public static partial class Utf8Formatter
		11		{
		12		private static bool TryFormatUInt64N(ulong value, byte precision, Span<byte> buffer, bool insertNegationSign, ou
	1	13		{
		14		// Calculate the actual digit count, number of group separators required, and the
		15		// number of trailing zeros requested. From all of this we can get the required
		16		// buffer length.
		17
	1	18		int digitCount = FormattingHelpers.CountDigits(value);
	1	19		int commaCount = (digitCount - 1) / 3;
	1	20		int trailingZeroCount = (precision == StandardFormat.NoPrecision) ? 2 /* default for 'N' */ : precision;
		21
	1	22		int requiredBufferLength = digitCount + commaCount;
	1	23		if (trailingZeroCount > 0)
	1	24		{
	1	25		requiredBufferLength += trailingZeroCount + 1;
	1	26		}
		27
	1	28		if (insertNegationSign)
	1	29		{
	1	30		requiredBufferLength++;
	1	31		}
		32
	1	33		if (requiredBufferLength > buffer.Length)
	1	34		{
	1	35		bytesWritten = 0;
	1	36		return false;
		37		}
		38
	1	39		bytesWritten = requiredBufferLength;
		40
	1	41		if (insertNegationSign)
	1	42		{
	1	43		buffer[0] = Utf8Constants.Minus;
	1	44		buffer = buffer.Slice(1);
	1	45		}
		46
	1	47		FormattingHelpers.WriteDigitsWithGroupSeparator(value, buffer.Slice(0, digitCount + commaCount));
		48
	1	49		if (trailingZeroCount > 0)
	1	50		{
	1	51		buffer[digitCount + commaCount] = Utf8Constants.Period;
	1	52		FormattingHelpers.FillWithAsciiZeros(buffer.Slice(digitCount + commaCount + 1, trailingZeroCount));
	1	53		}
		54
	1	55		return true;
	1	56		}
		57		}
		58		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.Integer.Unsigned.X.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		namespace System.Buffers.Text
		6		{
		7		/// <summary>
		8		/// Methods to format common data types as Utf8 strings.
		9		/// </summary>
		10		public static partial class Utf8Formatter
		11		{
		12		private static bool TryFormatUInt64X(ulong value, byte precision, bool useLower, Span<byte> buffer, out int byte
	1	13		{
	1	14		int actualDigitCount = FormattingHelpers.CountHexDigits(value);
	1	15		int computedOutputLength = (precision == StandardFormat.NoPrecision)
	1	16		? actualDigitCount
	1	17		: Math.Max(precision, actualDigitCount);
		18
	1	19		if (buffer.Length < computedOutputLength)
	1	20		{
	1	21		bytesWritten = 0;
	1	22		return false;
		23		}
		24
	1	25		bytesWritten = computedOutputLength;
	1	26		string hexTable = (useLower) ? FormattingHelpers.HexTableLower : FormattingHelpers.HexTableUpper;
		27
		28		// Writing the output backward in this manner allows the JIT to elide
		29		// bounds checking on the output buffer. The JIT won't elide the bounds
		30		// check on the hex table lookup, but we can live with that for now.
		31
		32		// It doesn't quite make sense to use the fast hex conversion functionality
		33		// for this method since that routine works on bytes, and here we're working
		34		// directly with nibbles. There may be opportunity for improvement by special-
		35		// casing output lengths of 2, 4, 8, and 16 and running them down optimized
		36		// code paths.
		37
	1	38		while ((uint)(--computedOutputLength) < (uint)buffer.Length)
	1	39		{
	1	40		buffer[computedOutputLength] = (byte)hexTable[(int)value & 0xf];
	1	41		value >>= 4;
	1	42		}
	1	43		return true;
	1	44		}
		45		}
		46		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Formatter\Utf8Formatter.TimeSpan.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Diagnostics;
		6
		7		namespace System.Buffers.Text
		8		{
		9		public static partial class Utf8Formatter
		10		{
		11		/// <summary>
		12		/// Formats a TimeSpan as a UTF8 string.
		13		/// </summary>
		14		/// <param name="value">Value to format</param>
		15		/// <param name="buffer">Buffer to write the UTF8-formatted value to</param>
		16		/// <param name="bytesWritten">Receives the length of the formatted text in bytes</param>
		17		/// <param name="format">The standard format to use</param>
		18		/// <returns>
		19		/// true for success. "bytesWritten" contains the length of the formatted text in bytes.
		20		/// false if buffer was too short. Iteratively increase the size of the buffer and retry until it succeeds.
		21		/// </returns>
		22		/// <remarks>
		23		/// Formats supported:
		24		///     c/t/T (default) [-][d.]hh:mm:ss[.fffffff]              (constant format)
		25		///     G               [-]d:hh:mm:ss.fffffff                  (general long)
		26		///     g               [-][d:][h]h:mm:ss[.f[f[f[f[f[f[f]]]]]] (general short)
		27		/// </remarks>
		28		/// <exceptions>
		29		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		30		/// </exceptions>
		31		public static bool TryFormat(TimeSpan value, Span<byte> buffer, out int bytesWritten, StandardFormat format = de
	1	32		{
	1	33		char symbol = FormattingHelpers.GetSymbolOrDefault(format, 'c');
		34
	1	35		switch (symbol)
		36		{
		37		case 'c':
		38		case 'G':
		39		case 'g':
	1	40		break;
		41
		42		case 't':
		43		case 'T':
	0	44		symbol = 'c';
	0	45		break;
		46
		47		default:
	1	48		return ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
		49		}
		50
		51		// First, calculate how large an output buffer is needed to hold the entire output.
		52
	1	53		int requiredOutputLength = 8; // start with "hh:mm:ss" and adjust as necessary
		54
		55		uint fraction;
		56		ulong totalSecondsRemaining;
	1	57		{
		58		// Turn this into a non-negative TimeSpan if possible.
	1	59		var ticks = value.Ticks;
	1	60		if (ticks < 0)
	1	61		{
	1	62		ticks = -ticks;
	1	63		if (ticks < 0)
	1	64		{
	1	65		Debug.Assert(ticks == Int64.MinValue /* -9223372036854775808 */);
		66
		67		// We computed these ahead of time; they're straight from the decimal representation of Int64.Mi
	1	68		fraction = 4775808;
	1	69		totalSecondsRemaining = 922337203685;
	1	70		goto AfterComputeFraction;
		71		}
	1	72		}
		73
	1	74		totalSecondsRemaining = FormattingHelpers.DivMod((ulong)Math.Abs(value.Ticks), TimeSpan.TicksPerSecond,
	1	75		fraction = (uint)fraction64;
	1	76		}
		77
	1	78		AfterComputeFraction:
		79
	1	80		int fractionDigits = 0;
	1	81		if (symbol == 'c')
	1	82		{
		83		// Only write out the fraction if it's non-zero, and in that
		84		// case write out the entire fraction (all digits).
	1	85		if (fraction != 0)
	1	86		{
	1	87		fractionDigits = Utf8Constants.DateTimeNumFractionDigits;
	1	88		}
	1	89		}
	1	90		else if (symbol == 'G')
	1	91		{
		92		// Always write out the fraction, even if it's zero.
	1	93		fractionDigits = Utf8Constants.DateTimeNumFractionDigits;
	1	94		}
		95		else
	1	96		{
		97		// Only write out the fraction if it's non-zero, and in that
		98		// case write out only the most significant digits.
	1	99		if (fraction != 0)
	1	100		{
	1	101		fractionDigits = Utf8Constants.DateTimeNumFractionDigits - FormattingHelpers.CountDecimalTrailingZer
	1	102		}
	1	103		}
		104
	1	105		Debug.Assert(fraction < 10_000_000);
		106
		107		// If we're going to write out a fraction, also need to write the leading decimal.
	1	108		if (fractionDigits != 0)
	1	109		{
	1	110		requiredOutputLength += fractionDigits + 1;
	1	111		}
		112
	1	113		ulong totalMinutesRemaining = 0;
	1	114		ulong seconds = 0;
	1	115		if (totalSecondsRemaining > 0)
	1	116		{
		117		// Only compute minutes if the TimeSpan has an absolute value of >= 1 minute.
	1	118		totalMinutesRemaining = FormattingHelpers.DivMod(totalSecondsRemaining, 60 /* seconds per minute */, out
	1	119		}
		120
	1	121		Debug.Assert(seconds < 60);
		122
	1	123		ulong totalHoursRemaining = 0;
	1	124		ulong minutes = 0;
	1	125		if (totalMinutesRemaining > 0)
	1	126		{
		127		// Only compute hours if the TimeSpan has an absolute value of >= 1 hour.
	1	128		totalHoursRemaining = FormattingHelpers.DivMod(totalMinutesRemaining, 60 /* minutes per hour */, out min
	1	129		}
		130
	1	131		Debug.Assert(minutes < 60);
		132
		133		// At this point, we can switch over to 32-bit divmod since the data has shrunk far enough.
	1	134		Debug.Assert(totalHoursRemaining <= UInt32.MaxValue);
		135
	1	136		uint days = 0;
	1	137		uint hours = 0;
	1	138		if (totalHoursRemaining > 0)
	1	139		{
		140		// Only compute days if the TimeSpan has an absolute value of >= 1 day.
	1	141		days = FormattingHelpers.DivMod((uint)totalHoursRemaining, 24 /* hours per day */, out hours);
	1	142		}
		143
	1	144		Debug.Assert(hours < 24);
		145
	1	146		int hourDigits = 2;
	1	147		if (hours < 10 && symbol == 'g')
	1	148		{
		149		// Only writing a one-digit hour, not a two-digit hour
	1	150		hourDigits--;
	1	151		requiredOutputLength--;
	1	152		}
		153
	1	154		int dayDigits = 0;
	1	155		if (days == 0)
	1	156		{
	1	157		if (symbol == 'G')
	1	158		{
	1	159		requiredOutputLength += 2; // for the leading "0:"
	1	160		dayDigits = 1;
	1	161		}
	1	162		}
		163		else
	1	164		{
	1	165		dayDigits = FormattingHelpers.CountDigits(days);
	1	166		requiredOutputLength += dayDigits + 1; // for the leading "d:" (or "d.")
	1	167		}
		168
	1	169		if (value.Ticks < 0)
	1	170		{
	1	171		requiredOutputLength++; // for the leading '-' sign
	1	172		}
		173
	1	174		if (buffer.Length < requiredOutputLength)
	1	175		{
	1	176		bytesWritten = 0;
	1	177		return false;
		178		}
		179
	1	180		bytesWritten = requiredOutputLength;
		181
	1	182		int idx = 0;
		183
		184		// Write leading '-' if necessary
	1	185		if (value.Ticks < 0)
	1	186		{
	1	187		buffer[idx++] = Utf8Constants.Minus;
	1	188		}
		189
		190		// Write day (and separator) if necessary
	1	191		if (dayDigits > 0)
	1	192		{
	1	193		FormattingHelpers.WriteDigits(days, buffer.Slice(idx, dayDigits));
	1	194		idx += dayDigits;
	1	195		buffer[idx++] = (symbol == 'c') ? Utf8Constants.Period : Utf8Constants.Colon;
	1	196		}
		197
		198		// Write "[h]h:mm:ss"
	1	199		FormattingHelpers.WriteDigits(hours, buffer.Slice(idx, hourDigits));
	1	200		idx += hourDigits;
	1	201		buffer[idx++] = Utf8Constants.Colon;
	1	202		FormattingHelpers.WriteDigits((uint)minutes, buffer.Slice(idx, 2));
	1	203		idx += 2;
	1	204		buffer[idx++] = Utf8Constants.Colon;
	1	205		FormattingHelpers.WriteDigits((uint)seconds, buffer.Slice(idx, 2));
	1	206		idx += 2;
		207
		208		// Write fraction (and separator) if necessary
	1	209		if (fractionDigits > 0)
	1	210		{
	1	211		buffer[idx++] = Utf8Constants.Period;
	1	212		FormattingHelpers.WriteDigits(fraction, buffer.Slice(idx, fractionDigits));
	1	213		idx += fractionDigits;
	1	214		}
		215
		216		// And we're done!
		217
	1	218		Debug.Assert(idx == requiredOutputLength);
	1	219		return true;
	1	220		}
		221		}
		222		}