CommonNetExtensions/CommonNet.Extensions.Tests/CommonNet.Extensions/WaitHandleExtensionsTests.cs at 09130a98211bd4fccba6453932f0de6815e108b2 · dmako/CommonNetExtensions · 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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
#pragma warning disable xUnit1031

using FluentAssertions;
using Xunit;

namespace CommonNet.Extensions.Tests;

public class WaitHandleExtensionsTests
{
    [Fact]
    public async Task AsTask_ShouldComplete_WhenWaitHandleIsSignaled()
    {
        using var manualResetEvent = new ManualResetEvent(false);

        var task = manualResetEvent.AsTask();
        task.IsCompleted.Should().BeFalse();

        manualResetEvent.Set();
        await task;

        task.IsCompleted.Should().BeTrue();
        task.Result.Should().BeTrue();
    }

    [Fact]
    public async Task AsTask_WithTimeout_ShouldComplete_WhenWaitHandleIsSignaled()
    {
        using var manualResetEvent = new ManualResetEvent(false);

        var task = manualResetEvent.AsTask(TimeSpan.FromSeconds(1));
        task.IsCompleted.Should().BeFalse();

        manualResetEvent.Set();
        await task;

        task.IsCompleted.Should().BeTrue();
        task.Result.Should().BeTrue();
    }

    [Fact]
    public async Task AsTask_WithTimeout_ShouldCancel_WhenTimeoutIsReached()
    {
        using var manualResetEvent = new ManualResetEvent(false);
        var task = manualResetEvent.AsTask(TimeSpan.FromMilliseconds(100));

        task.IsCompleted.Should().BeFalse();

        Exception? exception = null;
        try
        {
            await task;
        }
        catch (TaskCanceledException ex)
        {
            exception = ex;
        }
        catch (AggregateException ex) when (ex.InnerExceptions.Count == 1 && ex.InnerExceptions[0] is TaskCanceledException)
        {
            exception = ex;
        }

        exception.Should().NotBeNull();

        task.IsCanceled.Should().BeTrue();
    }


#if NET8_0_OR_GREATER

    [Fact]
    public async Task WaitAsync_WaitHandle_Signaled_CompletesTask()
    {
        using var manualEvent = new ManualResetEvent(false);
        WaitHandle waitHandle = manualEvent;
        var cancellationToken = CancellationToken.None;

        var task = waitHandle.WaitAsync(cancellationToken);
        manualEvent.Set();

        await task.Awaiting(t => t).Should().NotThrowAsync();
    }

    [Fact]
    public async Task WaitAsync_WaitHandle_Canceled_ThrowsTaskCanceledException()
    {
        using var manualEvent = new ManualResetEvent(false);
        WaitHandle waitHandle = manualEvent;
        var cts = new CancellationTokenSource();

        var task = waitHandle.WaitAsync(cts.Token);
        cts.Cancel();

        await task.Awaiting(t => t).Should().ThrowAsync<TaskCanceledException>();
    }

    [Fact]
    public async Task WaitAsync_ManualResetEventSlim_Signaled_CompletesTask()
    {

        using var manualResetEvent = new ManualResetEventSlim(false);
        var cancellationToken = CancellationToken.None;

        var task = manualResetEvent.WaitAsync(cancellationToken);
        manualResetEvent.Set();

        await task.Awaiting(t => t).Should().NotThrowAsync();
    }

    [Fact]
    public async Task WaitAsync_ManualResetEventSlim_Canceled_ThrowsTaskCanceledException()
    {
        // Arrange
        using var manualResetEvent = new ManualResetEventSlim(false);
        var cts = new CancellationTokenSource();

        var task = manualResetEvent.WaitAsync(cts.Token);
        cts.Cancel();

        await task.Awaiting(t => t).Should().ThrowAsync<TaskCanceledException>();
    }

    [Fact]
    public void WaitAsync_WaitHandle_Null_ThrowsArgumentNullException()
    {
        WaitHandle waitHandle = null!;
        var cancellationToken = CancellationToken.None;

        var func = () => waitHandle.WaitAsync(cancellationToken);
        func.Should().ThrowAsync<ArgumentException>();
    }

#endif

}

#pragma warning restore xUnit1031