am-wd/common
1
0
Fork 0
Code Actions Activity

Updating to VS 2026

Browse Source
This commit is contained in:
Andreas Müller
2025-11-13 20:30:44 +01:00
parent 1096186c40
commit 1767b55c8a
29 changed files with 230 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
test/AMWD.Common.Tests/AMWD.Common.Tests.csproj
View File

@@ -4,6 +4,10 @@
<TargetFramework>net8.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<Compile Include="..\MSTestSettings.cs" Link="MSTestSettings.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="DNS" Version="7.0.0" />
</ItemGroup>

82
test/AMWD.Common.Tests/Cli/CommandLineParserTest.cs
View File

@@ -19,7 +19,7 @@ namespace AMWD.Common.Tests.Cli
// assert
Assert.IsNotNull(result);
Assert.AreEqual(9, result.Length);
Assert.HasCount(9, result);
Assert.AreEqual("Option1", result[0]);
Assert.AreEqual("Option 2", result[1]);
@@ -44,7 +44,7 @@ namespace AMWD.Common.Tests.Cli
// assert
Assert.IsNotNull(args);
Assert.AreEqual(2, args.Length);
Assert.HasCount(2, args);
Assert.AreEqual("Option1", args[0]);
Assert.AreEqual("Option 2", args[1]);
@@ -66,27 +66,27 @@ namespace AMWD.Common.Tests.Cli
// assert
Assert.IsNotNull(options);
Assert.AreEqual(4, options.Count);
Assert.HasCount(4, options);
Assert.AreEqual(1, options.ElementAt(0).Names.Count);
Assert.HasCount(1, options.ElementAt(0).Names);
Assert.AreEqual("opt1", options.ElementAt(0).Names.First());
Assert.AreEqual(0, options.ElementAt(0).ParameterCount);
Assert.IsFalse(options.ElementAt(0).IsSingle);
Assert.IsFalse(options.ElementAt(0).IsRequired);
Assert.AreEqual(1, options.ElementAt(1).Names.Count);
Assert.HasCount(1, options.ElementAt(1).Names);
Assert.AreEqual("opt2", options.ElementAt(1).Names.First());
Assert.AreEqual(1, options.ElementAt(1).ParameterCount);
Assert.IsFalse(options.ElementAt(1).IsSingle);
Assert.IsFalse(options.ElementAt(1).IsRequired);
Assert.AreEqual(1, options.ElementAt(2).Names.Count);
Assert.HasCount(1, options.ElementAt(2).Names);
Assert.AreEqual("opt3", options.ElementAt(2).Names.First());
Assert.AreEqual(2, options.ElementAt(2).ParameterCount);
Assert.IsTrue(options.ElementAt(2).IsSingle);
Assert.IsTrue(options.ElementAt(2).IsRequired);
Assert.AreEqual(2, options.ElementAt(3).Names.Count);
Assert.HasCount(2, options.ElementAt(3).Names);
Assert.AreEqual("opt4", options.ElementAt(3).Names.First());
Assert.AreEqual("option4", options.ElementAt(3).Names.Last());
Assert.AreEqual(0, options.ElementAt(3).ParameterCount);
@@ -115,45 +115,45 @@ namespace AMWD.Common.Tests.Cli
// assert
Assert.IsFalse(opt.IsSet);
Assert.AreEqual(7, parser.Arguments.Length);
Assert.AreEqual(2, parser.FreeArguments.Length);
Assert.HasCount(7, parser.Arguments);
Assert.HasCount(2, parser.FreeArguments);
Assert.AreEqual("foo", parser.FreeArguments.First());
Assert.AreEqual("bar", parser.FreeArguments.Last());
Assert.IsTrue(parser.Arguments.ElementAt(0).Option.IsSet);
Assert.IsNull(parser.Arguments.ElementAt(0).Option.Value);
Assert.AreEqual(0, parser.Arguments.ElementAt(0).Values.Length);
Assert.IsEmpty(parser.Arguments.ElementAt(0).Values);
Assert.IsTrue(parser.Arguments.ElementAt(1).Option.IsSet);
Assert.AreEqual("two", parser.Arguments.ElementAt(1).Option.Value);
Assert.AreEqual(1, parser.Arguments.ElementAt(1).Values.Length);
Assert.HasCount(1, parser.Arguments.ElementAt(1).Values);
Assert.AreEqual("two", parser.Arguments.ElementAt(1).Values.First());
Assert.IsTrue(parser.Arguments.ElementAt(2).Option.IsSet);
Assert.AreEqual("three1", parser.Arguments.ElementAt(2).Option.Value);
Assert.AreEqual(2, parser.Arguments.ElementAt(2).Values.Length);
Assert.HasCount(2, parser.Arguments.ElementAt(2).Values);
Assert.AreEqual("three1", parser.Arguments.ElementAt(2).Values.First());
Assert.AreEqual("three2", parser.Arguments.ElementAt(2).Values.Last());
Assert.IsTrue(parser.Arguments.ElementAt(3).Option.IsSet);
Assert.AreEqual("four", parser.Arguments.ElementAt(3).Option.Value);
Assert.AreEqual(1, parser.Arguments.ElementAt(3).Values.Length);
Assert.HasCount(1, parser.Arguments.ElementAt(3).Values);
Assert.AreEqual("four", parser.Arguments.ElementAt(3).Values.First());
Assert.IsTrue(parser.Arguments.ElementAt(4).Option.IsSet);
Assert.AreEqual("testing", parser.Arguments.ElementAt(4).Option.Names.First());
Assert.AreEqual("done", parser.Arguments.ElementAt(4).Option.Value);
Assert.AreEqual(1, parser.Arguments.ElementAt(4).Values.Length);
Assert.HasCount(1, parser.Arguments.ElementAt(4).Values);
Assert.AreEqual("done", parser.Arguments.ElementAt(4).Values.First());
Assert.IsNull(parser.Arguments.ElementAt(5).Option);
Assert.AreEqual("foo", parser.Arguments.ElementAt(5).Value);
Assert.AreEqual(1, parser.Arguments.ElementAt(5).Values.Length);
Assert.HasCount(1, parser.Arguments.ElementAt(5).Values);
Assert.IsNull(parser.Arguments.ElementAt(6).Option);
Assert.AreEqual("bar", parser.Arguments.ElementAt(6).Value);
Assert.AreEqual(1, parser.Arguments.ElementAt(6).Values.Length);
Assert.HasCount(1, parser.Arguments.ElementAt(6).Values);
}
[TestMethod]
@@ -193,28 +193,23 @@ namespace AMWD.Common.Tests.Cli
var opts = parser.SetOptions;
// assert
Assert.AreEqual(2, opts.Length);
Assert.HasCount(2, opts);
Assert.AreEqual("opt1", opts.First().Names.First());
Assert.AreEqual("opt3", opts.Last().Names.First());
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowExceptionOnNullArgs()
{
string[] args = null;
var parser = new CommandLineParser();
// act
parser.Parse(args);
// assert - ArgumentNullException
Assert.Fail();
// act & assert
Assert.ThrowsExactly<ArgumentNullException>(() => parser.Parse(args));
}
[TestMethod]
[ExpectedException(typeof(Exception))]
public void ShouldThrowExceptionOnMultipleAutocomplete()
{
// arrange
@@ -226,15 +221,11 @@ namespace AMWD.Common.Tests.Cli
parser.RegisterOption("Option1", 1);
parser.RegisterOption("Option2", 1);
// act
parser.Parse(args);
// assert - Exception
Assert.Fail();
// act & assert
Assert.ThrowsExactly<Exception>(() => parser.Parse(args));
}
[TestMethod]
[ExpectedException(typeof(Exception))]
public void ShouldThrowExceptionOnMissingOption()
{
// arrange
@@ -246,15 +237,11 @@ namespace AMWD.Common.Tests.Cli
parser.RegisterOption("Opt1", 1);
parser.RegisterOption("Opt2", 1);
// act
parser.Parse(args);
// assert - Exception
Assert.Fail();
// act & assert
Assert.ThrowsExactly<Exception>(() => parser.Parse(args));
}
[TestMethod]
[ExpectedException(typeof(Exception))]
public void ShouldTrhowExceptionOnDuplicateOption()
{
// arrange
@@ -262,15 +249,11 @@ namespace AMWD.Common.Tests.Cli
var parser = new CommandLineParser();
parser.RegisterOption("opt", 1).Single();
// act
parser.Parse(args);
// assert - Exception
Assert.Fail();
// act & assert
Assert.ThrowsExactly<Exception>(() => parser.Parse(args));
}
[TestMethod]
[ExpectedException(typeof(Exception))]
public void ShouldThrowExceptionOnMissingArgument()
{
// arrange
@@ -278,15 +261,11 @@ namespace AMWD.Common.Tests.Cli
var parser = new CommandLineParser();
parser.RegisterOption("option", 1);
// act
parser.Parse(args);
// assert - Exception
Assert.Fail();
// act & assert
Assert.ThrowsExactly<Exception>(() => parser.Parse(args));
}
[TestMethod]
[ExpectedException(typeof(Exception))]
public void ShouldThrowExceptionForMissingRequiredOption()
{
// arrange
@@ -295,11 +274,8 @@ namespace AMWD.Common.Tests.Cli
parser.RegisterOption("opt").Required();
parser.RegisterOption("foo").Required();
// act
parser.Parse(args);
// assert - Exception
Assert.Fail();
// act & assert
Assert.ThrowsExactly<Exception>(() => parser.Parse(args));
}
}
}

10
test/AMWD.Common.Tests/Cli/EnumerableWalkerTest.cs
View File

@@ -16,16 +16,12 @@ namespace AMWD.Common.Tests.Cli
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowExceptionOnNullReference()
{
// arrange
// act
_ = new EnumerableWalker<object>(null);
// assert - ArgumentNullException
Assert.Fail();
// act & assert
Assert.ThrowsExactly<ArgumentNullException>(() => new EnumerableWalker<string>(null));
}
[TestMethod]
@@ -76,7 +72,7 @@ namespace AMWD.Common.Tests.Cli
public void ShouldReturnDefaultWhenNothingLeft()
{
// arrange
var walker = new EnumerableWalker<string>(Array.Empty<string>());
var walker = new EnumerableWalker<string>([]);
_ = walker.GetEnumerator();
// act

6
test/AMWD.Common.Tests/Comparer/DomainComparerTest.cs
View File

@@ -5,7 +5,7 @@ namespace AMWD.Common.Tests.Comparer
[TestClass]
public class DomainComparerTest
{
[DataTestMethod]
[TestMethod]
[DataRow("int", "internal")]
[DataRow("int", "dom.int")]
[DataRow("a.ins", "a.int")]
@@ -22,7 +22,7 @@ namespace AMWD.Common.Tests.Comparer
Assert.AreEqual(-1, result);
}
[DataTestMethod]
[TestMethod]
[DataRow("internal", "int")]
[DataRow("dom.int", "int")]
[DataRow("a.int", "a.ins")]
@@ -39,7 +39,7 @@ namespace AMWD.Common.Tests.Comparer
Assert.AreEqual(1, result);
}
[DataTestMethod]
[TestMethod]
[DataRow("internal", "internal")]
[DataRow("dom.int", "dom.int")]
[DataRow("a.internal", "a.internal")]

6
test/AMWD.Common.Tests/Comparer/IPAddressComparerTest.cs
View File

@@ -6,7 +6,7 @@ namespace AMWD.Common.Tests.Comparer
[TestClass]
public class IPAddressComparerTest
{
[DataTestMethod]
[TestMethod]
[DataRow("127.0.0.0", "127.0.0.1")]
[DataRow("fe80::", "fe80::1")]
[DataRow("::ffff:7f00:0", "127.0.0.1")]
@@ -22,7 +22,7 @@ namespace AMWD.Common.Tests.Comparer
Assert.AreEqual(-1, result);
}
[DataTestMethod]
[TestMethod]
[DataRow("127.0.0.1", "127.0.0.0")]
[DataRow("fe80::1", "fe80::")]
[DataRow("::ffff:7f00:1", "127.0.0.0")]
@@ -38,7 +38,7 @@ namespace AMWD.Common.Tests.Comparer
Assert.AreEqual(1, result);
}
[DataTestMethod]
[TestMethod]
[DataRow("127.0.0.1", "127.0.0.1")]
[DataRow("fe80::1", "fe80::1")]
[DataRow("::ffff:7f00:1", "127.0.0.1")]

6
test/AMWD.Common.Tests/Comparer/VersionStringComparerTest.cs
View File

@@ -5,7 +5,7 @@ namespace AMWD.Common.Tests.Comparer
[TestClass]
public class VersionStringComparerTest
{
[DataTestMethod]
[TestMethod]
[DataRow(null, "0")]
[DataRow("", "0")]
[DataRow("0", "1")]
@@ -25,7 +25,7 @@ namespace AMWD.Common.Tests.Comparer
Assert.AreEqual(-1, result);
}
[DataTestMethod]
[TestMethod]
[DataRow("0", null)]
[DataRow("0", "")]
[DataRow("1", "0")]
@@ -45,7 +45,7 @@ namespace AMWD.Common.Tests.Comparer
Assert.AreEqual(1, result);
}
[DataTestMethod]
[TestMethod]
[DataRow(null, null)]
[DataRow("", "")]
[DataRow("1", "1")]

76
test/AMWD.Common.Tests/Extensions/CollectionExtensionsTest.cs
View File

@@ -11,19 +11,19 @@ namespace AMWD.Common.Tests.Extensions
{
// Arrange
var item = new TestItem { Number = 10, Text = "Ten" };
ICollection<TestItem> list = new List<TestItem>
{
ICollection<TestItem> list =
[
new() {
Number = 1,
Text = "One"
}
};
];
// Act
list.AddIfNotNull(item);
// Assert
Assert.AreEqual(2, list.Count);
Assert.HasCount(2, list);
}
[TestMethod]
@@ -31,105 +31,95 @@ namespace AMWD.Common.Tests.Extensions
{
// Arrange
TestItem item = null;
ICollection<TestItem> list = new List<TestItem>
{
ICollection<TestItem> list =
[
new() {
Number = 1,
Text = "One"
}
};
];
// Act
list.AddIfNotNull(item);
// Assert
Assert.AreEqual(1, list.Count);
Assert.HasCount(1, list);
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionForNullList()
{
// Arrange
var item = new TestItem { Number = 10, Text = "Ten" };
ICollection<TestItem> list = null;
// Act
list.AddIfNotNull(item);
// Assert - ArgumentNullException
// Act & Assert
Assert.ThrowsExactly<ArgumentNullException>(() => list.AddIfNotNull(item));
}
[TestMethod]
public void ShouldAddRange()
{
// Arrange
ICollection<TestItem> items = new List<TestItem>
{
ICollection<TestItem> items =
[
new() { Number = 10, Text = "Ten" },
new() { Number = 11, Text = "Eleven" },
};
ICollection<TestItem> list = new List<TestItem>
{
];
ICollection<TestItem> list =
[
new() { Number = 1, Text = "One" },
};
// Act
list.AddRange(items);
// Act
.. items,
];
// Assert
Assert.AreEqual(3, list.Count);
Assert.HasCount(3, list);
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionForList()
{
// Arrange
ICollection<TestItem> items = new List<TestItem>
{
ICollection<TestItem> items =
[
new() { Number = 10, Text = "Ten" },
new() { Number = 11, Text = "Eleven" },
};
];
ICollection<TestItem> list = null;
// Act
list.AddRange(items);
// Assert - ArgumentNullException
// Act & Assert
Assert.ThrowsExactly<ArgumentNullException>(() => list.AddRange(items));
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionForItems()
{
// Arrange
ICollection<TestItem> items = null;
ICollection<TestItem> list = new List<TestItem>
{
ICollection<TestItem> list =
[
new() { Number = 1, Text = "One" },
};
];
// Act
list.AddRange(items);
// Assert - ArgumentNullException
// Act & Assert
Assert.ThrowsExactly<ArgumentNullException>(() => list.AddRange(items));
}
[TestMethod]
public void ShouldNotAddRange()
{
// Arrange
ICollection<TestItem> list = new List<TestItem>
{
ICollection<TestItem> list =
[
new() { Number = 1, Text = "One" },
};
];
// Act
list.AddRange(list);
// Assert
Assert.AreEqual(1, list.Count);
Assert.HasCount(1, list);
}
private class TestItem

14
test/AMWD.Common.Tests/Extensions/ReaderWriterLockSlimExtensionsTest.cs
View File

@@ -7,6 +7,8 @@ namespace AMWD.Common.Tests.Extensions
[TestClass]
public class ReaderWriterLockSlimExtensionsTest
{
public TestContext TestContext { get; set; }
[TestMethod]
public void ShouldEnterReadLock()
{
@@ -151,8 +153,8 @@ namespace AMWD.Common.Tests.Extensions
}
catch (Exception)
{ /* keep it quiet */ }
});
awaitableTask.Wait();
}, TestContext.CancellationToken);
awaitableTask.Wait(TestContext.CancellationToken);
// assert
Assert.IsTrue(isTimeout);
@@ -180,8 +182,8 @@ namespace AMWD.Common.Tests.Extensions
}
catch (Exception)
{ /* keep it quiet */ }
});
awaitableTask.Wait();
}, TestContext.CancellationToken);
awaitableTask.Wait(TestContext.CancellationToken);
// assert
Assert.IsTrue(isTimeout);
@@ -209,8 +211,8 @@ namespace AMWD.Common.Tests.Extensions
}
catch (Exception)
{ /* keep it quiet */ }
});
awaitableTask.Wait();
}, TestContext.CancellationToken);
awaitableTask.Wait(TestContext.CancellationToken);
// assert
Assert.IsTrue(isTimeout);

8
test/AMWD.Common.Tests/Extensions/StreamExtensionsTest.cs
View File

@@ -8,6 +8,8 @@ namespace AMWD.Common.Tests.Extensions
[TestClass]
public class StreamExtensionsTest
{
public TestContext TestContext { get; set; }
[TestMethod]
public void ShouldReadLineFromStreamSynchronous()
{
@@ -69,7 +71,7 @@ namespace AMWD.Common.Tests.Extensions
var stream = new MemoryStream(buffer);
// act
string line = await stream.ReadLineAsync();
string line = await stream.ReadLineAsync(cancellationToken: TestContext.CancellationToken);
// assert
Assert.AreEqual("First Line", line);
@@ -85,7 +87,7 @@ namespace AMWD.Common.Tests.Extensions
var stream = new MemoryStream(buffer);
// act
string line = await stream.ReadLineAsync();
string line = await stream.ReadLineAsync(cancellationToken: TestContext.CancellationToken);
// assert
Assert.AreEqual("Single Line", line);
@@ -100,7 +102,7 @@ namespace AMWD.Common.Tests.Extensions
var stream = new WriteOnlyStream();
// act
string line = await stream.ReadLineAsync();
string line = await stream.ReadLineAsync(cancellationToken: TestContext.CancellationToken);
// assert
Assert.IsNull(line);

22
test/AMWD.Common.Tests/Extensions/StringExtensionsTest.cs
View File

@@ -9,16 +9,13 @@ namespace AMWD.Common.Tests.Extensions
public class StringExtensionsTest
{
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionWhenNull()
{
// arrange
string hex = null;
// act
var bytes = hex.HexToBytes();
// assert - ArgumentNullException
// act & assert
Assert.ThrowsExactly<ArgumentNullException>(() => hex.HexToBytes());
}
[TestMethod]
@@ -35,19 +32,16 @@ namespace AMWD.Common.Tests.Extensions
Assert.IsFalse(bytes.Any());
}
[DataTestMethod]
[TestMethod]
[DataRow("aff", null)]
[DataRow("de:ad:be:e", ":")]
[DataRow("hell", "")]
[ExpectedException(typeof(FormatException))]
public void ShouldThrowFormatExceptionWhenInvalid(string hex, string delimiter)
{
// arrange
// act
var bytes = hex.HexToBytes(delimiter);
// assert - FormatException
// act & assert
Assert.ThrowsExactly<FormatException>(() => hex.HexToBytes(delimiter));
}
[TestMethod]
@@ -308,8 +302,8 @@ namespace AMWD.Common.Tests.Extensions
var nameserver = new IPEndPoint(IPAddress.Parse("1.1.1.1"), 53);
// act
bool valid = validEmail.IsValidEmailAddress(new[] { nameserver });
bool invalid = !invalidEmail.IsValidEmailAddress(new[] { nameserver });
bool valid = validEmail.IsValidEmailAddress([nameserver]);
bool invalid = !invalidEmail.IsValidEmailAddress([nameserver]);
// assert
Assert.IsTrue(valid);
@@ -349,7 +343,7 @@ namespace AMWD.Common.Tests.Extensions
// assert
Assert.AreEqual($"{value}\r{value}\r", sb.ToString());
Assert.IsFalse(sb.ToString().Contains('\n'));
Assert.DoesNotContain('\n', sb.ToString());
}
}
}

26
test/AMWD.Common.Tests/Logging/FileLoggerTest.cs
View File

@@ -83,51 +83,39 @@ namespace AMWD.Common.Tests.Logging
}
[TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public void ShouldThrowDisposedOnIsEnabled()
{
// arrange
var logger = GetFileLogger();
// act
logger.Dispose();
logger.IsEnabled(LogLevel.Error);
// assert - ObjectDisposedException
Assert.Fail();
// act & assert
Assert.ThrowsExactly<ObjectDisposedException>(() => logger.IsEnabled(LogLevel.Error));
}
[TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public void ShouldThrowDisposedOnLog()
{
// arrange
var logger = GetFileLogger();
// act
logger.Dispose();
logger.Log(LogLevel.None, "Some Message");
// assert - ObjectDisposedException
Assert.Fail();
// act & assert
Assert.ThrowsExactly<ObjectDisposedException>(() => logger.Log(LogLevel.None, "Some Message"));
}
[TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public void ShouldThrowDisposedOnBeginScope()
{
// arrange
var logger = GetFileLogger();
// act
logger.Dispose();
logger.BeginScope("foo");
// assert - ObjectDisposedException
Assert.Fail();
// act & assert
Assert.ThrowsExactly<ObjectDisposedException>(() => logger.BeginScope("foo"));
}
[DataTestMethod]
[TestMethod]
[DataRow(LogLevel.Trace, false)]
[DataRow(LogLevel.Debug, false)]
[DataRow(LogLevel.Information, false)]

66
test/AMWD.Common.Tests/Utilities/AsyncQueueTest.cs
View File

@@ -8,6 +8,8 @@ namespace AMWD.Common.Tests.Utilities
[TestClass]
public class AsyncQueueTest
{
public TestContext TestContext { get; set; }
private Queue<TestElement> _internalQueue;
private TestElement _queueElement1;
@@ -52,7 +54,7 @@ namespace AMWD.Common.Tests.Utilities
queue.Enqueue(element);
// assert
Assert.AreEqual(1, _internalQueue.Count);
Assert.HasCount(1, _internalQueue);
Assert.AreEqual(_internalQueue.Count, queue.Count);
}
@@ -69,11 +71,11 @@ namespace AMWD.Common.Tests.Utilities
// act
var task = Task.Run(async () =>
{
await queue.WaitAsync();
await queue.WaitAsync(TestContext.CancellationToken);
available = true;
});
}, TestContext.CancellationToken);
queue.Enqueue(element);
task.Wait();
task.Wait(TestContext.CancellationToken);
// assert
Assert.IsTrue(available);
@@ -92,10 +94,10 @@ namespace AMWD.Common.Tests.Utilities
// act
var task = Task.Run(async () =>
{
callback = await queue.DequeueAsync();
});
callback = await queue.DequeueAsync(TestContext.CancellationToken);
}, TestContext.CancellationToken);
queue.Enqueue(element);
task.Wait();
task.Wait(TestContext.CancellationToken);
// assert
Assert.IsNotNull(callback);
@@ -118,8 +120,8 @@ namespace AMWD.Common.Tests.Utilities
queue.Enqueue(elements);
// assert
Assert.AreEqual(2, _internalQueue.Count);
Assert.AreEqual(queue.Count, _internalQueue.Count);
Assert.HasCount(2, _internalQueue);
Assert.HasCount(queue.Count, _internalQueue);
}
[TestMethod]
@@ -229,12 +231,12 @@ namespace AMWD.Common.Tests.Utilities
var task = Task.Run(async () =>
{
await Task.Delay(1000);
queue.Enqueue(new[] { _queueElement1, _queueElement2, _queueElement3 });
});
await Task.Delay(1000, TestContext.CancellationToken);
queue.Enqueue([_queueElement1, _queueElement2, _queueElement3]);
}, TestContext.CancellationToken);
// act
var item = await queue.DequeueAsync();
var item = await queue.DequeueAsync(TestContext.CancellationToken);
// assert
Assert.AreEqual(2, queue.Count);
@@ -251,17 +253,17 @@ namespace AMWD.Common.Tests.Utilities
var task = Task.Run(async () =>
{
await Task.Delay(1000);
queue.Enqueue(new[] { _queueElement1, _queueElement2, _queueElement3 });
});
await Task.Delay(1000, TestContext.CancellationToken);
queue.Enqueue([_queueElement1, _queueElement2, _queueElement3]);
}, TestContext.CancellationToken);
// act
var items = await queue.DequeueManyAsync(2);
var items = await queue.DequeueManyAsync(2, TestContext.CancellationToken);
// assert
Assert.AreEqual(1, queue.Count);
Assert.IsNotNull(items);
Assert.AreEqual(2, items.Length);
Assert.HasCount(2, items);
Assert.AreEqual(_queueElement1, items[0]);
Assert.AreEqual(_queueElement2, items[1]);
}
@@ -275,17 +277,17 @@ namespace AMWD.Common.Tests.Utilities
var task = Task.Run(async () =>
{
await Task.Delay(1000);
queue.Enqueue(new[] { _queueElement1, _queueElement2, _queueElement3 });
});
await Task.Delay(1000, TestContext.CancellationToken);
queue.Enqueue([_queueElement1, _queueElement2, _queueElement3]);
}, TestContext.CancellationToken);
// act
var items = await queue.DequeueAvailableAsync();
var items = await queue.DequeueAvailableAsync(cancellationToken: TestContext.CancellationToken);
// assert
Assert.AreEqual(0, queue.Count);
Assert.IsNotNull(items);
Assert.AreEqual(3, items.Length);
Assert.HasCount(3, items);
Assert.AreEqual(_queueElement1, items[0]);
Assert.AreEqual(_queueElement2, items[1]);
Assert.AreEqual(_queueElement3, items[2]);
@@ -300,34 +302,30 @@ namespace AMWD.Common.Tests.Utilities
var task = Task.Run(async () =>
{
await Task.Delay(1000);
queue.Enqueue(new[] { _queueElement1, _queueElement2, _queueElement3 });
});
await Task.Delay(1000, TestContext.CancellationToken);
queue.Enqueue([_queueElement1, _queueElement2, _queueElement3]);
}, TestContext.CancellationToken);
// act
var items = await queue.DequeueAvailableAsync(2);
var items = await queue.DequeueAvailableAsync(2, TestContext.CancellationToken);
// assert
Assert.AreEqual(1, queue.Count);
Assert.IsNotNull(items);
Assert.AreEqual(2, items.Length);
Assert.HasCount(2, items);
Assert.AreEqual(_queueElement1, items[0]);
Assert.AreEqual(_queueElement2, items[1]);
}
[TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArumentOutOfRangeException()
{
// arrange
_internalQueue.Clear();
var queue = GetQueue();
// act
await queue.DequeueManyAsync(-2);
// assert - ArgumentOutOfRangeException expected
Assert.Fail();
// act & assert
await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(() => queue.DequeueManyAsync(-2, TestContext.CancellationToken));
}
private AsyncQueue<TestElement> GetQueue()

24
test/AMWD.Common.Tests/Utilities/CryptographyHelperTest.cs
View File

@@ -114,8 +114,8 @@ namespace UnitTests.Common.Utilities
// assert
CollectionAssert.AreNotEqual(cipher1, cipher2);
Assert.AreEqual(24, cipher1.Length);
Assert.AreEqual(24, cipher2.Length);
Assert.HasCount(24, cipher1);
Assert.HasCount(24, cipher2);
CollectionAssert.AreEqual(plain, plain1);
CollectionAssert.AreEqual(plain, plain2);
}
@@ -228,8 +228,8 @@ namespace UnitTests.Common.Utilities
// assert
CollectionAssert.AreNotEqual(cipher1, cipher2);
Assert.AreEqual(16, cipher1.Length);
Assert.AreEqual(16, cipher2.Length);
Assert.HasCount(16, cipher1);
Assert.HasCount(16, cipher2);
CollectionAssert.AreEqual(plain, plain1);
CollectionAssert.AreEqual(plain, plain2);
}
@@ -368,11 +368,11 @@ namespace UnitTests.Common.Utilities
byte[] bytes3 = CryptographyHelper.GetRandomBytes(length3);
// assert
Assert.AreEqual(length1, bytes1.Length);
Assert.AreEqual(length2, bytes2.Length);
Assert.AreEqual(length3, bytes3.Length);
Assert.HasCount(length1, bytes1);
Assert.HasCount(length2, bytes2);
Assert.HasCount(length3, bytes3);
Assert.IsTrue(bytes1.Length == bytes2.Length);
Assert.HasCount(bytes2.Length, bytes1);
CollectionAssert.AreNotEqual(bytes1, bytes2);
}
@@ -394,8 +394,8 @@ namespace UnitTests.Common.Utilities
Assert.AreEqual(length2, str2.Length);
Assert.AreEqual(length3, str3.Length);
Assert.IsTrue(str1.Length == str2.Length);
Assert.IsFalse(str1 == str2);
Assert.HasCount(str2.Length, str2);
Assert.AreNotEqual(str2, str1);
}
[TestMethod]
@@ -412,7 +412,7 @@ namespace UnitTests.Common.Utilities
// assert
Assert.AreEqual(length, str1.Length);
Assert.AreEqual(length, str2.Length);
Assert.IsFalse(str1 == str2);
Assert.AreNotEqual(str2, str1);
Assert.IsFalse(RandomStringWithPoolRegex().IsMatch(str1));
Assert.IsFalse(RandomStringWithPoolRegex().IsMatch(str2));
}
@@ -532,7 +532,7 @@ namespace UnitTests.Common.Utilities
Assert.IsFalse(fileExistsBefore);
Assert.IsNotNull(helper);
Assert.IsTrue(fileExistsAfter);
Assert.IsTrue(!string.IsNullOrWhiteSpace(content));
Assert.IsFalse(string.IsNullOrWhiteSpace(content));
}
[TestMethod]

9
test/AMWD.Common.Tests/Utilities/DelayedTaskTest.cs
View File

@@ -9,6 +9,8 @@ namespace AMWD.Common.Tests.Utilities
[TestClass]
public class DelayedTaskTest
{
public TestContext TestContext { get; set; }
[TestMethod]
public void ShouldCreateNewDelayedTaskNotStarting()
{
@@ -113,7 +115,7 @@ namespace AMWD.Common.Tests.Utilities
var cts = new CancellationTokenSource(delay.Add(TimeSpan.FromSeconds(1)));
sw.Start();
var delayedTask = DelayedTask.Run(Action, delay);
await Task.Delay(50);
await Task.Delay(50, TestContext.CancellationToken);
delayedTask.Reset();
SpinWait.SpinUntil(() => executionCount > 0 || cts.IsCancellationRequested);
@@ -142,7 +144,7 @@ namespace AMWD.Common.Tests.Utilities
var cts = new CancellationTokenSource(delay.Add(TimeSpan.FromSeconds(1)));
sw.Start();
var delayedTask = DelayedTask.Create(Action, delay);
await Task.Delay(50);
await Task.Delay(50, TestContext.CancellationToken);
bool isSuccess = delayedTask.ExecutePending();
SpinWait.SpinUntil(() => executionCount > 0 || cts.IsCancellationRequested);
sw.Stop();
@@ -173,7 +175,7 @@ namespace AMWD.Common.Tests.Utilities
var cts = new CancellationTokenSource(delay.Add(TimeSpan.FromSeconds(1)));
sw.Start();
var delayedTask = DelayedTask.Run(Action, delay);
await Task.Delay(50);
await Task.Delay(50, TestContext.CancellationToken);
bool isSuccess = delayedTask.ExecutePending();
SpinWait.SpinUntil(() => executionCount > 0 || cts.IsCancellationRequested);
@@ -205,7 +207,6 @@ namespace AMWD.Common.Tests.Utilities
// assert
Assert.IsNotNull(delayedTask);
Assert.IsNotNull(awaiter);
Assert.IsFalse(delayedTask.IsRunning);
Assert.IsFalse(delayedTask.IsWaitingToRun);
Assert.IsNull(delayedTask.Exception);