Mirrored_Repos/wabbajack
1
0
Fork 0
mirror of https://github.com/wabbajack-tools/wabbajack.git synced 2024-08-30 18:42:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move CSP tests into Commont.Test

Browse Source
This commit is contained in:
Timothy Baldridge 2020-03-25 22:34:43 -06:00
parent 51bad949ec
commit a7e220b779
2 changed files with 85 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
Wabbajack.Test/CSP/CSPTests.cs → Wabbajack.Common.Test/CSP/CSPTests.cs
View File

@ -2,43 +2,28 @@
using System.Reactive.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Wabbajack.Common.CSP;
using Xunit;
namespace Wabbajack.Test.CSP
namespace Wabbajack.Common.CSP.Test
{
[TestClass]
public class CSPTests
{
public TestContext TestContext { get; set; }
public void Log(string msg)
{
TestContext.WriteLine(msg);
}
[TestInitialize]
public void Startup()
{
}
/// <summary>
/// Test that we can put a value onto a channel without a buffer, and that the put is released once the
/// take finalizes
/// </summary>
/// <returns></returns>
[TestMethod]
[Fact]
public async Task TestTakePutBlocking()
{
var channel = Channel.Create<int>();
var ptask = channel.Put(1);
var (open, val) = await channel.Take();
Assert.AreEqual(1, val);
Assert.IsTrue(open);
Assert.IsTrue(await ptask);
Assert.Equal(1, val);
Assert.True(open);
Assert.True(await ptask);
}
/// <summary>
@ -46,7 +31,7 @@ namespace Wabbajack.Test.CSP
/// We can then take those items later on.
/// </summary>
/// <returns></returns>
[TestMethod]
[Fact]
public async Task TestTakePutBuffered()
{
var channel = Channel.Create<int>(10);
@ -56,8 +41,8 @@ namespace Wabbajack.Test.CSP
foreach (var itm in Enumerable.Range(0, 10))
{
var (is_open, val) = await channel.Take();
Assert.AreEqual(itm, val);
Assert.IsTrue(is_open);
Assert.Equal(itm, val);
Assert.True(is_open);
}
}
@ -65,7 +50,7 @@ namespace Wabbajack.Test.CSP
/// We can convert a IEnumerable into a channel by inlining the enumerable into the channel's buffer.
/// </summary>
/// <returns></returns>
[TestMethod]
[Fact]
public async Task TestToChannel()
{
var channel = Enumerable.Range(0, 10).ToChannel();
@ -73,8 +58,8 @@ namespace Wabbajack.Test.CSP
foreach (var itm in Enumerable.Range(0, 10))
{
var (is_open, val) = await channel.Take();
Assert.AreEqual(itm, val);
Assert.IsTrue(is_open);
Assert.Equal(itm, val);
Assert.True(is_open);
}
}
@ -84,12 +69,12 @@ namespace Wabbajack.Test.CSP
/// TakeAll returns a list of the items taken.
/// </summary>
/// <returns></returns>
[TestMethod]
[Fact]
public async Task TestTakeAll()
{
var results = await Enumerable.Range(0, 10).ToChannel().TakeAll();
CollectionAssert.AreEqual(Enumerable.Range(0, 10).ToList(), results);
Assert.Equal(Enumerable.Range(0, 10).ToList(), results);
}
/// <summary>
@ -99,7 +84,7 @@ namespace Wabbajack.Test.CSP
/// cheap.
/// </summary>
/// <returns></returns>
[TestMethod]
[Fact]
public async Task RxTransformInChannel()
{
var chan = Channel.Create<int, int>(1, o => o.Select(v => v + 1));
@ -108,13 +93,13 @@ namespace Wabbajack.Test.CSP
foreach (var itm in Enumerable.Range(0, 10))
{
var (is_open, val) = await chan.Take();
Assert.AreEqual(itm + 1, val);
Assert.IsTrue(is_open);
Assert.Equal(itm + 1, val);
Assert.True(is_open);
}
await finished;
}
[TestMethod]
[Fact]
public async Task UnorderedPipeline()
{
var o = Channel.Create<string>(3);
@ -124,11 +109,11 @@ namespace Wabbajack.Test.CSP
var results = (await o.TakeAll()).OrderBy(e => e).ToList();
var expected = Enumerable.Range(0, 3).Select(i => i.ToString()).OrderBy(e => e).ToList();
CollectionAssert.AreEqual(expected, results);
Assert.Equal(expected, results);
}
[TestMethod]
[Fact]
public async Task UnorderedPipelineWithParallelism()
{
// Do it a hundred times to try and catch rare deadlocks
@ -139,11 +124,11 @@ namespace Wabbajack.Test.CSP
var results = (await o.TakeAll()).OrderBy(e => e).ToList();
var expected = Enumerable.Range(0, 1024).Select(i => i.ToString()).OrderBy(e => e).ToList();
CollectionAssert.AreEqual(expected, results);
Assert.Equal(expected, results);
await finished;
}
[TestMethod]
[Fact]
public async Task UnorderedTaskPipeline()
{
// Do it a hundred times to try and catch rare deadlocks
@ -158,11 +143,11 @@ namespace Wabbajack.Test.CSP
var results = (await o.TakeAll()).OrderBy(e => e).ToList();
var expected = Enumerable.Range(0, 1024).ToList();
CollectionAssert.AreEqual(expected, results);
Assert.Equal(expected, results);
await finished;
}
[TestMethod]
[Fact]
public async Task UnorderedThreadPipeline()
{
// Do it a hundred times to try and catch rare deadlocks
@ -177,11 +162,11 @@ namespace Wabbajack.Test.CSP
var results = (await o.TakeAll()).OrderBy(e => e).ToList();
var expected = Enumerable.Range(0, 1024).ToList();
CollectionAssert.AreEqual(expected, results);
Assert.Equal(expected, results);
await finished;
}
[TestMethod]
[Fact]
public async Task ChannelStressTest()
{
var chan = Channel.Create<int>();
@ -201,7 +186,7 @@ namespace Wabbajack.Test.CSP
for (var i = 0; i < 1000; i++)
{
var (is_open, val) = await chan.Take();
Assert.AreEqual(i, val);
Assert.Equal(i, val);
}
}
finally
@ -214,7 +199,7 @@ namespace Wabbajack.Test.CSP
await taker;
}
[TestMethod]
[Fact]
public async Task ChannelStressWithBuffer()
{
var chan = Channel.Create<int>(1);
@ -234,7 +219,7 @@ namespace Wabbajack.Test.CSP
for (var i = 0; i < 1000; i++)
{
var (is_open, val) = await chan.Take();
Assert.AreEqual(i, val);
Assert.Equal(i, val);
}
}
finally

113
Wabbajack.Test/CSP/ChannelTests.cs → Wabbajack.Common.Test/CSP/ChannelTests.cs
View File

@ -1,15 +1,14 @@
using System.Linq;
using System.Reactive.Linq;
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Wabbajack.Common.CSP;
using Xunit;
namespace Wabbajack.Test.CSP
namespace Wabbajack.Common.CSP.Test
{
[TestClass]
public class ChannelTests
{
[TestMethod]
[Fact]
public async Task PutThenTakeNoBuffer()
{
var chan = Channel.Create<int>();
@ -17,11 +16,11 @@ namespace Wabbajack.Test.CSP
var putter = chan.Put(42);
var taker = chan.Take();
Assert.IsTrue(await putter);
Assert.AreEqual((true, 42), await taker);
Assert.True(await putter);
Assert.Equal((true, 42), await taker);
}
[TestMethod]
[Fact]
public async Task TakeThenPushNoBuffer()
{
var chan = Channel.Create<int>();
@ -29,11 +28,11 @@ namespace Wabbajack.Test.CSP
var taker = chan.Take();
var putter = chan.Put(42);
Assert.IsTrue(await putter);
Assert.AreEqual((true, 42), await taker);
Assert.True(await putter);
Assert.Equal((true, 42), await taker);
}
[TestMethod]
[Fact]
public async Task TakeFromBufferAfterPut()
{
var chan = Channel.Create<int>(1);
@ -41,11 +40,11 @@ namespace Wabbajack.Test.CSP
var putter = chan.Put(42);
var taker = chan.Take();
Assert.IsTrue(await putter);
Assert.AreEqual((true, 42), await taker);
Assert.True(await putter);
Assert.Equal((true, 42), await taker);
}
[TestMethod]
[Fact]
public async Task TakeFromBufferBeforePut()
{
var chan = Channel.Create<int>(1);
@ -53,12 +52,12 @@ namespace Wabbajack.Test.CSP
var taker = chan.Take();
var putter = chan.Put(42);
Assert.IsTrue(await putter);
Assert.AreEqual((true, 42), await taker);
Assert.True(await putter);
Assert.Equal((true, 42), await taker);
}
[TestMethod]
[Fact]
public async Task TakesAreReleasedAfterClose()
{
var chan = Channel.Create<int>();
@ -66,10 +65,10 @@ namespace Wabbajack.Test.CSP
var taker = chan.Take();
chan.Close();
Assert.AreEqual((false, 0), await taker);
Assert.Equal((false, 0), await taker);
}
[TestMethod]
[Fact]
public async Task ExpandingTransformsReleaseMultipleTakes()
{
var chan = Channel.Create<int, int>(1, i => i.SelectMany(len => Enumerable.Range(0, len)));
@ -78,11 +77,11 @@ namespace Wabbajack.Test.CSP
var take2 = chan.Take();
await chan.Put(2);
Assert.AreEqual((true, 0), await take1);
Assert.AreEqual((true, 1), await take2);
Assert.Equal((true, 0), await take1);
Assert.Equal((true, 1), await take2);
}
[TestMethod]
[Fact]
public async Task TransformsCanCloseChannel()
{
var chan = Channel.Create<int, int>(1, i => i.Take(1));
@ -93,13 +92,13 @@ namespace Wabbajack.Test.CSP
await chan.Put(1);
await chan.Put(2);
Assert.IsTrue(chan.IsClosed);
Assert.True(chan.IsClosed);
Assert.AreEqual((true, 1), await take1);
Assert.AreEqual((false, 0), await take2);
Assert.Equal((true, 1), await take1);
Assert.Equal((false, 0), await take2);
}
[TestMethod]
[Fact]
public async Task TransformsCanCloseDuringExpand()
{
var chan = Channel.Create<int, int>(1, i => i.SelectMany(len => Enumerable.Range(1, len)).Take(1));
@ -109,13 +108,13 @@ namespace Wabbajack.Test.CSP
await chan.Put(2);
Assert.IsTrue(chan.IsClosed);
Assert.True(chan.IsClosed);
Assert.AreEqual((true, 1), await take1);
Assert.AreEqual((false, 0), await take2);
Assert.Equal((true, 1), await take1);
Assert.Equal((false, 0), await take2);
}
[TestMethod]
[Fact]
public async Task TransformsCanFilterTakeFirst()
{
var chan = Channel.Create<int, int>(1, i => i.Where(x => x == 2));
@ -127,13 +126,13 @@ namespace Wabbajack.Test.CSP
await chan.Put(2);
chan.Close();
Assert.IsTrue(chan.IsClosed);
Assert.True(chan.IsClosed);
Assert.AreEqual((true, 2), await take1);
Assert.AreEqual((false, 0), await take2);
Assert.Equal((true, 2), await take1);
Assert.Equal((false, 0), await take2);
}
[TestMethod]
[Fact]
public async Task TransformsCanReturnNothingTakeFirst()
{
var chan = Channel.Create<int, int>(1, i => i.Take(0));
@ -143,13 +142,13 @@ namespace Wabbajack.Test.CSP
await chan.Put(1);
Assert.IsTrue(chan.IsClosed);
Assert.True(chan.IsClosed);
Assert.AreEqual((false, 0), await take1);
Assert.AreEqual((false, 0), await take2);
Assert.Equal((false, 0), await take1);
Assert.Equal((false, 0), await take2);
}
[TestMethod]
[Fact]
public async Task TransformsCanFilterTakeAfter()
{
var chan = Channel.Create<int, int>(1, i => i.Where(x => x == 2));
@ -162,13 +161,13 @@ namespace Wabbajack.Test.CSP
var take2 = chan.Take();
chan.Close();
Assert.IsTrue(chan.IsClosed);
Assert.True(chan.IsClosed);
Assert.AreEqual((true, 2), await take1);
Assert.AreEqual((false, 0), await take2);
Assert.Equal((true, 2), await take1);
Assert.Equal((false, 0), await take2);
}
[TestMethod]
[Fact]
public async Task TransformsCanReturnNothingTakeAfter()
{
var chan = Channel.Create<int, int>(1, i => i.Take(0));
@ -179,37 +178,37 @@ namespace Wabbajack.Test.CSP
var take2 = chan.Take();
Assert.IsTrue(chan.IsClosed);
Assert.True(chan.IsClosed);
Assert.AreEqual((false, 0), await take1);
Assert.AreEqual((false, 0), await take2);
Assert.Equal((false, 0), await take1);
Assert.Equal((false, 0), await take2);
}
[TestMethod]
[Fact]
public void TooManyTakesCausesException()
{
var chan = Channel.Create<int>();
Assert.ThrowsException<ManyToManyChannel<int, int>.TooManyHanldersException>(() =>
Assert.Throws<ManyToManyChannel<int, int>.TooManyHanldersException>(() =>
{
for (var x = 0; x < ManyToManyChannel<int, int>.MAX_QUEUE_SIZE + 1; x++)
chan.Take();
});
}
[TestMethod]
[Fact]
public void TooManyPutsCausesException()
{
var chan = Channel.Create<int>();
Assert.ThrowsException<ManyToManyChannel<int, int>.TooManyHanldersException>(() =>
Assert.Throws<ManyToManyChannel<int, int>.TooManyHanldersException>(() =>
{
for (var x = 0; x < ManyToManyChannel<int, int>.MAX_QUEUE_SIZE + 1; x++)
chan.Put(x);
});
}
[TestMethod]
[Fact]
public async Task BlockingPutsGoThroughTransform()
{
var chan = Channel.Create<int, int>(1, i => i.Take(2));
@ -225,15 +224,15 @@ namespace Wabbajack.Test.CSP
Assert.AreEqual((true, 1), await take1);
Assert.AreEqual((true, 2), await take2);
Assert.AreEqual((false, 0), await take3);
Assert.Equal((true, 1), await take1);
Assert.Equal((true, 2), await take2);
Assert.Equal((false, 0), await take3);
Assert.IsTrue(await put1);
Assert.IsTrue(await put2);
Assert.IsFalse(await put3);
Assert.IsFalse(await put4);
Assert.IsTrue(chan.IsClosed);
Assert.True(await put1);
Assert.True(await put2);
Assert.False(await put3);
Assert.False(await put4);
Assert.True(chan.IsClosed);
}
}
}