Skip to content

Throw ArgumentException for invalid DateTimeStyles in TryParse/TryParseExact #122

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
OlegRa merged 1 commit into from
Jul 11, 2026
Merged

Throw ArgumentException for invalid DateTimeStyles in TryParse/TryParseExact #122

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
44 changes: 32 additions & 12 deletions DateTimeOnly.Tests/ArgumentValidationTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -77,6 +77,12 @@ public void DateOnlyTryParseValidationWorkedTest()

Assert.False(DateOnly.TryParse("aa-bb-cc", out dateOnly));
Assert.Equal(default, dateOnly);

Assert.Equal(StyleArgumentName, Assert.Throws<ArgumentException>(
() => DateOnly.TryParse("aa-bb-cc".AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateOnly)).ParamName);

Assert.Equal(StyleArgumentName, Assert.Throws<ArgumentException>(
() => DateOnly.TryParse("aa-bb-cc", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateOnly)).ParamName);
}

[Fact]
Expand Down Expand Up @@ -131,13 +137,17 @@ public void DateOnlyTryParseExactValidationWorkedTest()
DateTimeStyles.AllowWhiteSpaces, out dateOnly));
Assert.Equal(default, dateOnly);

Assert.False(DateOnly.TryParseExact(
string.Empty, string.Empty, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out dateOnly));
Assert.Equal(default, dateOnly);
Assert.Equal(StyleArgumentName, Assert.Throws<ArgumentException>(
() => DateOnly.TryParseExact(
string.Empty, string.Empty, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out dateOnly)).ParamName);

Assert.False(DateOnly.TryParseExact(
new ReadOnlySpan<char>(), string.Empty.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out dateOnly));
Assert.Equal(default, dateOnly);
Assert.Equal(StyleArgumentName, Assert.Throws<ArgumentException>(
() => DateOnly.TryParseExact(
new ReadOnlySpan<char>(), string.Empty.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out dateOnly)).ParamName);

Assert.Equal(StyleArgumentName, Assert.Throws<ArgumentException>(
() => DateOnly.TryParseExact(
string.Empty, [string.Empty], CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out dateOnly)).ParamName);

Assert.False(DateOnly.TryParseExact("aa-bb-cc", "dd-MM-YY", out dateOnly));
Assert.Equal(default, dateOnly);
Expand Down Expand Up @@ -201,6 +211,12 @@ public void TimeOnlyTryParseValidationWorkedTest()

Assert.False(TimeOnly.TryParse("aa:bb", out timeOnly));
Assert.Equal(default, timeOnly);

Assert.Equal(StyleArgumentName, Assert.Throws<ArgumentException>(
() => TimeOnly.TryParse("aa:bb".AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out timeOnly)).ParamName);

Assert.Equal(StyleArgumentName, Assert.Throws<ArgumentException>(
() => TimeOnly.TryParse("aa:bb", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out timeOnly)).ParamName);
}

[Fact]
Expand Down Expand Up @@ -255,13 +271,17 @@ public void TimeOnlyTryParseExactValidationWorkedTest()
DateTimeStyles.AllowWhiteSpaces, out timeOnly));
Assert.Equal(default, timeOnly);

Assert.False(TimeOnly.TryParseExact(
string.Empty, string.Empty, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out timeOnly));
Assert.Equal(default, timeOnly);
Assert.Equal(StyleArgumentName, Assert.Throws<ArgumentException>(
() => TimeOnly.TryParseExact(
string.Empty, string.Empty, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out timeOnly)).ParamName);

Assert.False(TimeOnly.TryParseExact(
new ReadOnlySpan<char>(), string.Empty.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out timeOnly));
Assert.Equal(default, timeOnly);
Assert.Equal(StyleArgumentName, Assert.Throws<ArgumentException>(
() => TimeOnly.TryParseExact(
new ReadOnlySpan<char>(), string.Empty.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out timeOnly)).ParamName);

Assert.Equal(StyleArgumentName, Assert.Throws<ArgumentException>(
() => TimeOnly.TryParseExact(
string.Empty, [string.Empty], CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out timeOnly)).ParamName);

Assert.False(TimeOnly.TryParseExact("aa-bb-cc", "dd-MM-YY", out timeOnly));
Assert.Equal(default, timeOnly);
Expand Down
8 changes: 4 additions & 4 deletions DateTimeOnly.Tests/DateOnlyTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -353,13 +353,13 @@ public static void BasicFormatParseTest()
Assert.Equal(dateOnly, parsedDateOnly);
Assert.Equal(dateOnly, parsedDateOnly1);

Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out parsedDateOnly1));
Assert.Throws<ArgumentException>(() => DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out parsedDateOnly1));
Assert.Throws<ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal));
Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out parsedDateOnly1));
Assert.Throws<ArgumentException>(() => DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out parsedDateOnly1));
Assert.Throws<ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal));
Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out parsedDateOnly1));
Assert.Throws<ArgumentException>(() => DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out parsedDateOnly1));
Assert.Throws<ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal));
Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault, out parsedDateOnly1));
Assert.Throws<ArgumentException>(() => DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault, out parsedDateOnly1));
Assert.Throws<ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault));

s = " " + s + " ";
Expand Down
8 changes: 4 additions & 4 deletions DateTimeOnly.Tests/TimeOnlyTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -391,13 +391,13 @@ public static void BasicFormatParseTest()
Assert.True(TimeOnly.TryParse(s.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.None, out parsedTimeOnly1));
Assert.Equal(parsedTimeOnly, parsedTimeOnly1);

Assert.False(TimeOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out parsedTimeOnly1));
AssertExtensions.Throws<ArgumentException>("style", () => TimeOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out parsedTimeOnly1));
AssertExtensions.Throws<ArgumentException>("style", () => TimeOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal));
Assert.False(TimeOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out parsedTimeOnly1));
AssertExtensions.Throws<ArgumentException>("style", () => TimeOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out parsedTimeOnly1));
AssertExtensions.Throws<ArgumentException>("style", () => TimeOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal));
Assert.False(TimeOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out parsedTimeOnly1));
AssertExtensions.Throws<ArgumentException>("style", () => TimeOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out parsedTimeOnly1));
AssertExtensions.Throws<ArgumentException>("style", () => TimeOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal));
Assert.False(TimeOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault, out parsedTimeOnly1));
AssertExtensions.Throws<ArgumentException>("style", () => TimeOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault, out parsedTimeOnly1));
AssertExtensions.Throws<ArgumentException>("style", () => TimeOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault));

s = " " + s + " ";
Expand Down
32 changes: 27 additions & 5 deletions DateTimeOnly/DateOnly.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -436,7 +436,15 @@ public static DateOnly ParseExact(string s, [StringSyntax(StringSyntaxAttribute.
/// <param name="style">A bitwise combination of enumeration values that indicates the permitted format of s. A typical value to specify is None.</param>
/// <param name="result">When this method returns, contains the DateOnly value equivalent to the date contained in s, if the conversion succeeded, or MinValue if the conversion failed. The conversion fails if the s parameter is empty string, or does not contain a valid string representation of a date. This parameter is passed uninitialized.</param>
/// <returns>true if the s parameter was converted successfully; otherwise, false.</returns>
public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, DateTimeStyles style, out DateOnly result) => TryParseInternal(s, provider, style, out result) == ParseFailureKind.None;
public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
{
if ((style & ~DateTimeStyles.AllowWhiteSpaces) != 0)
{
throw new ArgumentException(SR.Argument_InvalidDateStyles, nameof(style));
}

return TryParseInternal(s, provider, style, out result) == ParseFailureKind.None;
}

private static ParseFailureKind TryParseInternal(ReadOnlySpan<char> s, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
{
Expand Down Expand Up @@ -485,8 +493,15 @@ private static ParseFailureKind TryParseInternal(ReadOnlySpan<char> s, IFormatPr
/// <param name="style">A bitwise combination of one or more enumeration values that indicate the permitted format of s.</param>
/// <param name="result">When this method returns, contains the DateOnly value equivalent to the date contained in s, if the conversion succeeded, or MinValue if the conversion failed. The conversion fails if the s is empty string, or does not contain a date that correspond to the pattern specified in format. This parameter is passed uninitialized.</param>
/// <returns>true if s was converted successfully; otherwise, false.</returns>
public static bool TryParseExact(ReadOnlySpan<char> s, [StringSyntax(StringSyntaxAttribute.DateOnlyFormat)] ReadOnlySpan<char> format, IFormatProvider? provider, DateTimeStyles style, out DateOnly result) =>
TryParseExactInternal(s, format, provider, style, out result) == ParseFailureKind.None;
public static bool TryParseExact(ReadOnlySpan<char> s, [StringSyntax(StringSyntaxAttribute.DateOnlyFormat)] ReadOnlySpan<char> format, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
{
if ((style & ~DateTimeStyles.AllowWhiteSpaces) != 0)
{
throw new ArgumentException(SR.Argument_InvalidDateStyles, nameof(style));
}

return TryParseExactInternal(s, format, provider, style, out result) == ParseFailureKind.None;
}
private static ParseFailureKind TryParseExactInternal(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
{
if ((style & ~DateTimeStyles.AllowWhiteSpaces) != 0)
Expand Down Expand Up @@ -549,8 +564,15 @@ private static ParseFailureKind TryParseExactInternal(ReadOnlySpan<char> s, Read
/// <param name="style">A bitwise combination of enumeration values that defines how to interpret the parsed date. A typical value to specify is None.</param>
/// <param name="result">When this method returns, contains the DateOnly value equivalent to the date contained in s, if the conversion succeeded, or MinValue if the conversion failed. The conversion fails if the s parameter is Empty, or does not contain a valid string representation of a date. This parameter is passed uninitialized.</param>
/// <returns>true if the s parameter was converted successfully; otherwise, false.</returns>
public static bool TryParseExact(ReadOnlySpan<char> s, [NotNullWhen(true), StringSyntax(StringSyntaxAttribute.DateOnlyFormat)] string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out DateOnly result) =>
TryParseExactInternal(s, formats, provider, style, out result) == ParseFailureKind.None;
public static bool TryParseExact(ReadOnlySpan<char> s, [NotNullWhen(true), StringSyntax(StringSyntaxAttribute.DateOnlyFormat)] string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
{
if ((style & ~DateTimeStyles.AllowWhiteSpaces) != 0)
{
throw new ArgumentException(SR.Argument_InvalidDateStyles, nameof(style));
}

return TryParseExactInternal(s, formats, provider, style, out result) == ParseFailureKind.None;
}

private static ParseFailureKind TryParseExactInternal(ReadOnlySpan<char> s, string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
{
Expand Down
33 changes: 27 additions & 6 deletions DateTimeOnly/TimeOnly.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -603,8 +603,15 @@ public static TimeOnly ParseExact(string s, [StringSyntax(StringSyntaxAttribute.
/// <param name="result">When this method returns, contains the TimeOnly value equivalent to the time contained in s, if the conversion succeeded, or MinValue if the conversion failed. The conversion fails if the s parameter is empty string, or does not contain a valid string representation of a date. This parameter is passed uninitialized.</param>
/// <returns>true if the s parameter was converted successfully; otherwise, false.</returns>
/// <inheritdoc cref="ISpanParsable{TSelf}.TryParse(ReadOnlySpan{char}, IFormatProvider?, out TSelf)" />
public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result) =>
TryParseInternal(s, provider, style, out result) == ParseFailureKind.None;
public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
{
if ((style & ~DateTimeStyles.AllowWhiteSpaces) != 0)
{
throw new ArgumentException(SR.Argument_InvalidDateStyles, nameof(style));
}

return TryParseInternal(s, provider, style, out result) == ParseFailureKind.None;
}
private static ParseFailureKind TryParseInternal(ReadOnlySpan<char> s, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
{
if ((style & ~DateTimeStyles.AllowWhiteSpaces) != 0)
Expand Down Expand Up @@ -654,8 +661,15 @@ private static ParseFailureKind TryParseInternal(ReadOnlySpan<char> s, IFormatPr
/// <param name="style">A bitwise combination of one or more enumeration values that indicate the permitted format of s.</param>
/// <param name="result">When this method returns, contains the TimeOnly value equivalent to the time contained in s, if the conversion succeeded, or MinValue if the conversion failed. The conversion fails if the s is empty string, or does not contain a time that correspond to the pattern specified in format. This parameter is passed uninitialized.</param>
/// <returns>true if s was converted successfully; otherwise, false.</returns>
public static bool TryParseExact(ReadOnlySpan<char> s, [StringSyntax(StringSyntaxAttribute.TimeOnlyFormat)] ReadOnlySpan<char> format, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result) =>
TryParseExactInternal(s, format, provider, style, out result) == ParseFailureKind.None;
public static bool TryParseExact(ReadOnlySpan<char> s, [StringSyntax(StringSyntaxAttribute.TimeOnlyFormat)] ReadOnlySpan<char> format, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
{
if ((style & ~DateTimeStyles.AllowWhiteSpaces) != 0)
{
throw new ArgumentException(SR.Argument_InvalidDateStyles, nameof(style));
}

return TryParseExactInternal(s, format, provider, style, out result) == ParseFailureKind.None;
}

private static ParseFailureKind TryParseExactInternal(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
{
Expand Down Expand Up @@ -719,8 +733,15 @@ private static ParseFailureKind TryParseExactInternal(ReadOnlySpan<char> s, Read
/// <param name="style">A bitwise combination of enumeration values that defines how to interpret the parsed time. A typical value to specify is None.</param>
/// <param name="result">When this method returns, contains the TimeOnly value equivalent to the time contained in s, if the conversion succeeded, or MinValue if the conversion failed. The conversion fails if the s parameter is Empty, or does not contain a valid string representation of a time. This parameter is passed uninitialized.</param>
/// <returns>true if the s parameter was converted successfully; otherwise, false.</returns>
public static bool TryParseExact(ReadOnlySpan<char> s, [NotNullWhen(true), StringSyntax(StringSyntaxAttribute.TimeOnlyFormat)] string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result) =>
TryParseExactInternal(s, formats, provider, style, out result) == ParseFailureKind.None;
public static bool TryParseExact(ReadOnlySpan<char> s, [NotNullWhen(true), StringSyntax(StringSyntaxAttribute.TimeOnlyFormat)] string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
{
if ((style & ~DateTimeStyles.AllowWhiteSpaces) != 0)
{
throw new ArgumentException(SR.Argument_InvalidDateStyles, nameof(style));
}

return TryParseExactInternal(s, formats, provider, style, out result) == ParseFailureKind.None;
}

private static ParseFailureKind TryParseExactInternal(ReadOnlySpan<char> s, string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
{
Expand Down