System.DateTimeOnly/DateTimeOnly.Tests/FastStrictParsingLogicTests.cs at master · OlegRa/System.DateTimeOnly · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
using System.Diagnostics.CodeAnalysis;
using Xunit;

namespace System.Tests;

// ReSharper disable once ClassNeverInstantiated.Global
#pragma warning disable IDE0079
[SuppressMessage("ReSharper", "SuggestVarOrType_BuiltInTypes")]
#pragma warning restore IDE0079
public sealed class FastStrictParsingLogicTests
{
    private const string DateOnlyFormat = "d";

    private const string TimeOnlyFormat = "t";

    [Fact]
    public static void DateOnlyParseWorkedTest() =>
        DateOnlyParseWorked(DateTime.Today, DateOnlyFormat);

    [Fact]
    public static void MidnightDateOnlyParseFailedTest() =>
        DateOnlyParseFailed(DateTime.Today, TimeOnlyFormat);

    [Fact]
    public static void MidnightTimeOnlyParseWorkedTest() =>
        TimeOnlyParseWorked(DateTime.MinValue, TimeOnlyFormat);

    [Fact]
    public static void DateTimeMinValueTimeOnlyParseFailedTest() =>
        TimeOnlyParseFailed(DateTime.MinValue, DateOnlyFormat);

    [Fact]
    public static void MidnightDateOnlyParseWorkedTest() =>
        RunInFastParsingLogicContext(
            (dt, format) => DateOnlyParseWorked(dt, format, DateTime.MinValue),
            DateTime.Today, TimeOnlyFormat);

    [Fact]
    public static void DateTimeMinValueDateOnlyParseWorkedTest() =>
        RunInFastParsingLogicContext(DateOnlyParseWorked, DateTime.MinValue, TimeOnlyFormat);

    [Fact]
    public static void DateTimeMinValueTimeOnlyParseWorkedTest() =>
        RunInFastParsingLogicContext(TimeOnlyParseWorked,DateTime.MinValue, DateOnlyFormat);

    private static void RunInFastParsingLogicContext(Action<DateTime, string> testMethod, DateTime dt, string format)
    {
        const string appContextSwitchName = "Portable.System.DateTimeOnly.UseFastParsingLogic";

        AppContext.SetSwitch(appContextSwitchName, true);
        try
        {
            testMethod(dt, format);
        }
        finally
        {
            AppContext.SetSwitch(appContextSwitchName, false);
        }
    }

    private static void TimeOnlyParseWorked(DateTime dt, string format)
    {
        string formatted = dt.ToString(format);
        Assert.Equal(TimeOnly.FromDateTime(dt), TimeOnly.Parse(formatted));
        Assert.Equal(TimeOnly.FromDateTime(dt), TimeOnly.Parse(formatted.AsSpan()));
        Assert.True(TimeOnly.TryParse(formatted, out _));
        Assert.True(TimeOnly.TryParse(formatted.AsSpan(), out _));
    }

    private static void DateOnlyParseWorked(DateTime dt, string format) =>
        DateOnlyParseWorked(dt, format, dt);

    private static void DateOnlyParseWorked(DateTime dt, string format, DateTime @default)
    {
        string formatted = dt.ToString(format);
        Assert.Equal(DateOnly.FromDateTime(@default), DateOnly.Parse(formatted));
        Assert.Equal(DateOnly.FromDateTime(@default), DateOnly.Parse(formatted.AsSpan()));
        Assert.True(DateOnly.TryParse(formatted, out _));
        Assert.True(DateOnly.TryParse(formatted.AsSpan(), out _));
    }

    private static void TimeOnlyParseFailed(DateTime dt, string format)
    {
        string formatted = dt.ToString(format);
        Assert.Throws<FormatException>(() => TimeOnly.Parse(formatted));
        Assert.Throws<FormatException>(() => TimeOnly.Parse(formatted.AsSpan()));
        Assert.False(TimeOnly.TryParse(formatted, out _));
        Assert.False(TimeOnly.TryParse(formatted.AsSpan(), out _));
    }

    private static void DateOnlyParseFailed(DateTime dt, string format)
    {
        string formatted = dt.ToString(format);
        Assert.Throws<FormatException>(() => DateOnly.Parse(formatted));
        Assert.Throws<FormatException>(() => DateOnly.Parse(formatted.AsSpan()));
        Assert.False(DateOnly.TryParse(formatted, out _));
        Assert.False(DateOnly.TryParse(formatted.AsSpan(), out _));
    }
}