Skip to content

Remove some redundant threading tests, move some cases to libraries tests #59073

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
merged 6 commits into from
Oct 28, 2021
Merged

Remove some redundant threading tests, move some cases to libraries tests #59073

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
8c67476
Remove some redundant threading tests, move some cases to libraries t…
Sep 11, 2021
51d1640
Fix tests for wasm
Sep 14, 2021
2e3f936
Fix test
Sep 30, 2021
a164c35
Separate basic functionality tests
Oct 25, 2021
a0528d8
Add null checks for failed TryOpen out parameter
Oct 25, 2021
f0d2084
Fix failures
Oct 26, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
The table of contents is too big for display.
Diff view
Diff view
  •  
  •  
  •  
159 changes: 140 additions & 19 deletions src/libraries/System.Threading/tests/AutoResetEventTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,30 +8,151 @@ namespace System.Threading.Tests
{
public class AutoResetEventTests
{
private const int FailedWaitTimeout = 30000;
[Fact]
public void ConstructorAndDisposeTest()
{
var e = new AutoResetEvent(false);
Assert.False(e.WaitOne(0));
e.Dispose();
Assert.Throws<ObjectDisposedException>(() => e.Reset());
Assert.Throws<ObjectDisposedException>(() => e.Set());
Assert.Throws<ObjectDisposedException>(() => e.WaitOne(0));

e = new AutoResetEvent(true);
Assert.True(e.WaitOne(0));
e.Dispose();
}

[Fact]
public void Ctor()
public void SetAndResetTest()
{
using (AutoResetEvent are = new AutoResetEvent(false))
Assert.False(are.WaitOne(0));
var e = new AutoResetEvent(true);
e.Reset();
Assert.False(e.WaitOne(0));
Assert.False(e.WaitOne(0));
e.Reset();
Assert.False(e.WaitOne(0));
e.Set();
Assert.True(e.WaitOne(0));
Assert.False(e.WaitOne(0));
e.Set();
e.Set();
Assert.True(e.WaitOne(0));
}

[Fact]
public void WaitTest()
{
var e = new AutoResetEvent(true);
e.CheckedWait();
Assert.False(e.WaitOne(0));
e.Set();
e.CheckedWait();
Assert.False(e.WaitOne(0));

e.Reset();
Assert.False(e.WaitOne(ThreadTestHelpers.ExpectedTimeoutMilliseconds));
}

[Fact]
public void MultiWaitWithAllIndexesSetTest()
{
var es =
new AutoResetEvent[]
{
new AutoResetEvent(true),
new AutoResetEvent(true),
new AutoResetEvent(true),
new AutoResetEvent(true)
};
Assert.Equal(0, WaitHandle.WaitAny(es, 0));
for (int i = 0; i < es.Length; ++i)
{
Assert.Equal(i > 0, es[i].WaitOne(0));
es[i].Set();
}
Assert.Equal(0, WaitHandle.WaitAny(es, ThreadTestHelpers.UnexpectedTimeoutMilliseconds));
for (int i = 0; i < es.Length; ++i)
{
Assert.Equal(i > 0, es[i].WaitOne(0));
es[i].Set();
}
Assert.Equal(0, WaitHandle.WaitAny(es));
for (int i = 0; i < es.Length; ++i)
{
Assert.Equal(i > 0, es[i].WaitOne(0));
es[i].Set();
}
Assert.True(WaitHandle.WaitAll(es, 0));
for (int i = 0; i < es.Length; ++i)
{
Assert.False(es[i].WaitOne(0));
es[i].Set();
}
Assert.True(WaitHandle.WaitAll(es, ThreadTestHelpers.UnexpectedTimeoutMilliseconds));
for (int i = 0; i < es.Length; ++i)
{
Assert.False(es[i].WaitOne(0));
es[i].Set();
}
Assert.True(WaitHandle.WaitAll(es));
for (int i = 0; i < es.Length; ++i)
{
Assert.False(es[i].WaitOne(0));
}
}

using (AutoResetEvent are = new AutoResetEvent(true))
Assert.True(are.WaitOne(0));
[Fact]
public void MultiWaitWithInnerIndexesSetTest()
{
var es =
new AutoResetEvent[]
{
new AutoResetEvent(false),
new AutoResetEvent(true),
new AutoResetEvent(true),
new AutoResetEvent(false)
};
Assert.Equal(1, WaitHandle.WaitAny(es, 0));
for (int i = 0; i < es.Length; ++i)
{
Assert.Equal(i == 2, es[i].WaitOne(0));
}
es[1].Set();
es[2].Set();
Assert.Equal(1, WaitHandle.WaitAny(es, ThreadTestHelpers.UnexpectedTimeoutMilliseconds));
for (int i = 0; i < es.Length; ++i)
{
Assert.Equal(i == 2, es[i].WaitOne(0));
}
es[1].Set();
es[2].Set();
Assert.False(WaitHandle.WaitAll(es, 0));
Assert.False(WaitHandle.WaitAll(es, ThreadTestHelpers.ExpectedTimeoutMilliseconds));
for (int i = 0; i < es.Length; ++i)
{
Assert.Equal(i == 1 || i == 2, es[i].WaitOne(0));
}
}

[Fact]
public void SetReset()
public void MultiWaitWithAllIndexesResetTest()
{
using (AutoResetEvent are = new AutoResetEvent(false))
var es =
new AutoResetEvent[]
{
new AutoResetEvent(false),
new AutoResetEvent(false),
new AutoResetEvent(false),
new AutoResetEvent(false)
};
Assert.Equal(WaitHandle.WaitTimeout, WaitHandle.WaitAny(es, 0));
Assert.Equal(WaitHandle.WaitTimeout, WaitHandle.WaitAny(es, ThreadTestHelpers.ExpectedTimeoutMilliseconds));
Assert.False(WaitHandle.WaitAll(es, 0));
Assert.False(WaitHandle.WaitAll(es, ThreadTestHelpers.ExpectedTimeoutMilliseconds));
for (int i = 0; i < es.Length; ++i)
{
Assert.False(are.WaitOne(0));
are.Set();
Assert.True(are.WaitOne(0));
Assert.False(are.WaitOne(0));
are.Set();
are.Reset();
Assert.False(are.WaitOne(0));
Assert.False(es[i].WaitOne(0));
}
}

Expand All @@ -58,7 +179,7 @@ public void WaitHandleWaitAll()
for (int i = 0; i < handles.Length; i++)
handles[i] = new AutoResetEvent(false);

Task<bool> t = Task.Run(() => WaitHandle.WaitAll(handles, FailedWaitTimeout));
Task<bool> t = Task.Run(() => WaitHandle.WaitAll(handles, ThreadTestHelpers.UnexpectedTimeoutMilliseconds));
for (int i = 0; i < handles.Length; i++)
{
Assert.False(t.IsCompleted);
Expand All @@ -76,7 +197,7 @@ public void WaitHandleWaitAny()
for (int i = 0; i < handles.Length; i++)
handles[i] = new AutoResetEvent(false);

Task<int> t = Task.Run(() => WaitHandle.WaitAny(handles, FailedWaitTimeout));
Task<int> t = Task.Run(() => WaitHandle.WaitAny(handles, ThreadTestHelpers.UnexpectedTimeoutMilliseconds));
handles[5].Set();
Assert.Equal(5, t.Result);

Expand All @@ -95,15 +216,15 @@ public void PingPong()
{
for (int i = 0; i < Iters; i++)
{
Assert.True(are1.WaitOne(FailedWaitTimeout));
are1.CheckedWait();
are2.Set();
}
}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default),
Task.Factory.StartNew(() =>
{
for (int i = 0; i < Iters; i++)
{
Assert.True(are2.WaitOne(FailedWaitTimeout));
are2.CheckedWait();
are1.Set();
}
}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default));
Expand Down
15 changes: 13 additions & 2 deletions src/libraries/System.Threading/tests/EventWaitHandleTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -84,24 +84,29 @@ public void SetReset()
using (EventWaitHandle are = new EventWaitHandle(false, EventResetMode.AutoReset))
{
Assert.False(are.WaitOne(0));
Assert.False(are.WaitOne(ThreadTestHelpers.ExpectedTimeoutMilliseconds));
are.Set();
Assert.True(are.WaitOne(0));
Assert.False(are.WaitOne(0));
Assert.False(are.WaitOne(ThreadTestHelpers.ExpectedTimeoutMilliseconds));
are.Set();
are.Reset();
Assert.False(are.WaitOne(0));
Assert.False(are.WaitOne(ThreadTestHelpers.ExpectedTimeoutMilliseconds));
}

using (EventWaitHandle mre = new EventWaitHandle(false, EventResetMode.ManualReset))
{
Assert.False(mre.WaitOne(0));
Assert.False(mre.WaitOne(ThreadTestHelpers.ExpectedTimeoutMilliseconds));
mre.Set();
Assert.True(mre.WaitOne(0));
Assert.True(mre.WaitOne(0));
mre.Set();
Assert.True(mre.WaitOne(0));
mre.Reset();
Assert.False(mre.WaitOne(0));
Assert.False(mre.WaitOne(ThreadTestHelpers.ExpectedTimeoutMilliseconds));
}
}

Expand Down Expand Up @@ -158,8 +163,14 @@ public void OpenExisting_UnavailableName_Windows()
{
string name = Guid.NewGuid().ToString("N");
Assert.Throws<WaitHandleCannotBeOpenedException>(() => EventWaitHandle.OpenExisting(name));
EventWaitHandle ignored;
Assert.False(EventWaitHandle.TryOpenExisting(name, out ignored));
EventWaitHandle e;
Assert.False(EventWaitHandle.TryOpenExisting(name, out e));
Assert.Null(e);

using (e = new EventWaitHandle(false, EventResetMode.AutoReset, name)) { }
Assert.Throws<WaitHandleCannotBeOpenedException>(() => EventWaitHandle.OpenExisting(name));
Assert.False(EventWaitHandle.TryOpenExisting(name, out e));
Assert.Null(e);
}

[PlatformSpecific(TestPlatforms.Windows)] // OpenExisting not supported on Unix
Expand Down
Loading