From f6ad1317024bd56e5fec12aacf8ddeb362a8085c Mon Sep 17 00:00:00 2001 From: Herman Schoenfeld Date: Thu, 9 May 2024 17:24:04 +1000 Subject: [PATCH] Upgrade to NUnit 4 --- src/Hydrogen.NUnit.DB/DACTestFixture.cs | 7 +- .../Hydrogen.NUnit.DB.csproj | 2 +- src/Hydrogen.NUnit/AssertEx.cs | 39 +- src/Hydrogen.NUnit/Hydrogen.NUnit.csproj | 4 +- src/Hydrogen.NUnit/NUnitTool.cs | 9 +- .../RPCComplexTests.cs | 2 +- .../RPCSimpleTests.cs | 324 ++++++------ .../Bip340SchnorrTest.cs | 39 +- .../BitcoinBase58EncodingTests.cs | 25 +- tests/Hydrogen.CryptoEx.Tests/CryptoTest.cs | 18 +- tests/Hydrogen.CryptoEx.Tests/DigestTest.cs | 13 +- tests/Hydrogen.CryptoEx.Tests/ECDSATests.cs | 37 +- tests/Hydrogen.CryptoEx.Tests/ECIESTests.cs | 9 +- tests/Hydrogen.CryptoEx.Tests/HashTestBase.cs | 7 +- .../MuSigBuilderTest.cs | 31 +- tests/Hydrogen.CryptoEx.Tests/MuSigTest.cs | 25 +- .../Murmur3_x86_32DigestTest.cs | 3 +- .../OpenSSLConsistencyTests.cs | 7 +- .../Pascal64EncodingTests.cs | 17 +- .../PascalAsciiEncodingTests.cs | 17 +- .../PascalBase58EncodingTests.cs | 4 +- .../PascalCoinEciesTest.cs | 4 +- .../RegisterCryptoExModule.cs | 6 +- .../HexEncodingTests.cs | 17 +- .../RandomHash2Test.cs | 8 +- tests/Hydrogen.DApp.Core.Tests/TargetTests.cs | 7 +- tests/Hydrogen.DApp.Core.Tests/UInt256Test.cs | 106 ++-- .../ZipPackageTest.cs | 91 ++-- .../ComponentTests/BlockMenuTests.cs | 4 +- .../NavigationTests/AppMenuTests.cs | 7 +- .../NavigationTests/DefaultAppManagerTests.cs | 21 +- .../DefaultPluginManagerTests.cs | 5 +- .../PluginTests/MenuItemTests.cs | 17 +- .../PagedTableViewModelTests.cs | 33 +- .../RapidTableViewModelTests.cs | 5 +- .../VirtualPagedTableViewModelTests.cs | 21 +- .../Wizard/DefaultWizardTests.cs | 71 +-- tests/Hydrogen.Data.Tests/DACScopeTests.cs | 35 +- tests/Hydrogen.Data.Tests/MSSQLToolTest.cs | 9 +- tests/Hydrogen.Data.Tests/SqliteDACTests.cs | 11 +- tests/Hydrogen.Data.Tests/SqliteToolTest.cs | 21 +- .../TransactionScopeCompatibilityTests.cs | 19 +- .../Math/MathCompilerParserTests.cs | 35 +- .../Math/MathCompilerScannerTests.cs | 161 +++--- tests/Hydrogen.Tests/Cache/CacheTests.cs | 63 +-- .../Hydrogen.Tests/Cache/PooledCacheTests.cs | 57 +-- .../Hydrogen.Tests/Cache/SessionCacheTests.cs | 33 +- .../Collections/Buffer/BufferTests.cs | 107 ++-- .../Buffer/FileMappedBufferTests.cs | 147 +++--- .../Buffer/MerklePagedBufferTest.cs | 13 +- .../PagedBufferImplementationHelperTests.cs | 3 +- .../Dictionaries/BijectiveDictionaryTests.cs | 5 +- .../Dictionaries/MultiKeyDictionaryTest.cs | 27 +- .../Dictionaries/ReferenceDictionaryTests.cs | 9 +- .../Lists/RecyclableListTestsBase.cs | 9 +- .../Collections/Lists/UpdateOnlyListTests.cs | 11 +- .../Collections/Other/BitVectorTests.cs | 21 +- .../Other/EnumerableExtensionTests.cs | 7 +- .../Collections/Paged/MemoryPagedListTests.cs | 475 +++++++++--------- .../Queue/ProducerConsumerQueueTest.cs | 13 +- .../Collections/Sets/BloomFilterTests.cs | 11 +- .../Collections/Sets/ReferenceHashSetTests.cs | 5 +- .../StreamMapped/StreamMappedListTests.cs | 45 +- .../StreamMappedMerkleDictionaryCLKTests.cs | 2 +- .../StreamMappedMerkleDictionaryTestsBase.cs | 3 +- .../StreamMappedMerkleRecyclableListTests.cs | 9 +- ...treamMappedRecyclableListWithIndexTests.cs | 9 +- .../StreamPaged/StreamPagedListTests.cs | 63 +-- .../FileTransactionScopeTests.cs | 55 +- .../Transactional/FileTransactionTests.cs | 41 +- .../TransactionalFileMappedBufferTests.cs | 139 ++--- .../Comparers/ByteArrayComparerTests.cs | 11 +- .../ByteArrayEqualityComparerTests.cs | 13 +- .../Comparers/ComparerBuilderTests.cs | 3 +- .../Comparers/PackedComparerTests.cs | 13 +- .../Comparers/PackedEqualityComparerTests.cs | 19 +- tests/Hydrogen.Tests/Crypto/HashersTests.cs | 3 +- .../Hydrogen.Tests/Crypto/SubRootTreeTests.cs | 22 +- tests/Hydrogen.Tests/Crypto/WAMSTests.cs | 15 +- tests/Hydrogen.Tests/Crypto/WOTSSharpTests.cs | 13 +- tests/Hydrogen.Tests/Crypto/WOTSTests.cs | 21 +- tests/Hydrogen.Tests/DateTime/ApproxEqual.cs | 15 +- .../Hydrogen.Tests/DateTime/FormatExTests.cs | 79 +-- .../Environment/CommandLineArgsTests.cs | 122 ++--- .../FileSystem/FileSystemTests.cs | 7 +- tests/Hydrogen.Tests/Hydrogen.Tests.csproj | 1 + .../Iterator/AppendIteratorTests.cs | 11 +- .../Memory/MemoryMetricTests.cs | 13 +- .../Merkle/FlatMerkleTreeTests.cs | 35 +- .../Merkle/LongMerkleTreeTests.cs | 21 +- .../Hydrogen.Tests/Merkle/MerkleMathTests.cs | 189 +++---- .../Hydrogen.Tests/Merkle/MerkleProofTests.cs | 13 +- .../Hydrogen.Tests/Merkle/MerkleTreeTests.cs | 31 +- .../Merkle/SimpleMerkleTreeTests.cs | 15 +- tests/Hydrogen.Tests/Misc/BitsTests.cs | 33 +- .../Hydrogen.Tests/Misc/MiscellaneousTests.cs | 3 +- tests/Hydrogen.Tests/Misc/RandomTests.cs | 17 +- .../Misc/RecursiveDataTypeTests.cs | 7 +- tests/Hydrogen.Tests/Misc/ResultTests.cs | 9 +- .../Hydrogen.Tests/Scopes/ContextScopeTest.cs | 77 +-- .../Serialization/AutoSizedSerializerTest.cs | 1 - .../Serialization/DefaultSerializerTests.cs | 33 +- .../Serialization/PaddedSerializerTests.cs | 3 +- .../PolymorphicSerializerTests.cs | 83 +++ .../Serialization/SerializerFactoryTests.cs | 9 +- .../Streams/ExtendedMemoryStreamTests.cs | 25 +- .../Streams/FragmentedStreamTests.cs | 57 +-- tests/Hydrogen.Tests/Text/ParserTests.cs | 25 +- .../Text/StringFormatterTests.cs | 35 +- tests/Hydrogen.Tests/Text/StringTests.cs | 25 +- tests/Hydrogen.Tests/Text/UrlIDTests.cs | 3 +- .../Threading/ProducerConsumerLockTests.cs | 14 +- .../Hydrogen.Tests/Threading/SchedulerTest.cs | 45 +- .../Threading/ThroughputOptimizerTests.cs | 149 +++--- tests/Hydrogen.Tests/Values/CVarIntTests.cs | 7 +- tests/Hydrogen.Tests/Values/VarIntTests.cs | 5 +- .../LevelDBTests.cs | 35 +- .../WindowsSecurityTest.cs | 213 ++++---- 118 files changed, 2255 insertions(+), 2078 deletions(-) create mode 100644 tests/Hydrogen.Tests/Serialization/PolymorphicSerializerTests.cs diff --git a/src/Hydrogen.NUnit.DB/DACTestFixture.cs b/src/Hydrogen.NUnit.DB/DACTestFixture.cs index 323c5bcfd..8531f3ca0 100644 --- a/src/Hydrogen.NUnit.DB/DACTestFixture.cs +++ b/src/Hydrogen.NUnit.DB/DACTestFixture.cs @@ -31,6 +31,7 @@ using Hydrogen.Data; using Tools; using Object = Tools.Object; +using NUnit.Framework.Legacy; namespace Hydrogen.NUnit { public abstract class DACTestFixture { @@ -110,7 +111,7 @@ protected virtual void DropDatabase(IDAC dac) { protected virtual void AssertSameTableRowCount(IDAC source, IDAC dest, string tableName) { var sourceCount = source.Count(tableName); var destCount = dest.Count(tableName); - Assert.AreEqual(sourceCount, destCount); + ClassicAssert.AreEqual(sourceCount, destCount); } // ReSharper disable once InconsistentNaming @@ -156,8 +157,8 @@ private void AssertSameTableDataInternal(IDAC source, IDAC dest, string tableNam var sourceTableSchema = source.GetSchemaCached()[tableName]; var destTableSchema = dest.GetSchemaCached()[tableName]; - Assert.AreNotEqual(DBKeyType.None, sourceTableSchema.PrimaryKey.KeyType, "Tables without primary keys are not supported"); - Assert.AreEqual(sourceTableSchema.PrimaryKey.KeyType, destTableSchema.PrimaryKey.KeyType, "Table primary key types do not match"); + ClassicAssert.AreNotEqual(DBKeyType.None, sourceTableSchema.PrimaryKey.KeyType, "Tables without primary keys are not supported"); + ClassicAssert.AreEqual(sourceTableSchema.PrimaryKey.KeyType, destTableSchema.PrimaryKey.KeyType, "Table primary key types do not match"); var sourceData = source.Select(tableName).Rows.Cast().Select(r => r.ItemArray.Select(Object.SanitizeObject).ToArray()).ToArray(); var destData = dest.Select(tableName).Rows.Cast().Select(r => r.ItemArray.Select(Object.SanitizeObject).ToArray()).ToArray(); diff --git a/src/Hydrogen.NUnit.DB/Hydrogen.NUnit.DB.csproj b/src/Hydrogen.NUnit.DB/Hydrogen.NUnit.DB.csproj index 3c7ab62e0..a37479327 100644 --- a/src/Hydrogen.NUnit.DB/Hydrogen.NUnit.DB.csproj +++ b/src/Hydrogen.NUnit.DB/Hydrogen.NUnit.DB.csproj @@ -1,7 +1,7 @@  - netstandard2.1 + net8.0 true diff --git a/src/Hydrogen.NUnit/AssertEx.cs b/src/Hydrogen.NUnit/AssertEx.cs index 8638a588f..ff32ccab3 100644 --- a/src/Hydrogen.NUnit/AssertEx.cs +++ b/src/Hydrogen.NUnit/AssertEx.cs @@ -13,6 +13,7 @@ using System.Linq; using System.Text.RegularExpressions; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.NUnit; @@ -727,7 +728,7 @@ public static void StreamIntegrationTests(int maxSize, Stream actualStream, Stre expectedStream.Seek(segment.Start, SeekOrigin.Begin); actualStream.Seek(segment.Start, SeekOrigin.Begin); if (runAsserts) { - Assert.AreEqual(expectedStream.ReadBytes(count), actualStream.ReadBytes(count)); + ClassicAssert.AreEqual(expectedStream.ReadBytes(count), actualStream.ReadBytes(count)); AreEqual(expectedStream, actualStream); } extraTest?.Invoke(); @@ -774,18 +775,18 @@ public static void AreEqual(Stream expected, Stream actual) { public static void AreEqual(IDynamicMerkleTree expected, IDynamicMerkleTree actual) { - Assert.AreEqual(expected.Size, actual.Size); - Assert.AreEqual(expected.Leafs.Count, actual.Leafs.Count); - Assert.AreEqual(expected.Leafs.ToArray(), actual.Leafs.ToArray()); - Assert.AreEqual(expected.Root, actual.Root); + ClassicAssert.AreEqual(expected.Size, actual.Size); + ClassicAssert.AreEqual(expected.Leafs.Count, actual.Leafs.Count); + ClassicAssert.AreEqual(expected.Leafs.ToArray(), actual.Leafs.ToArray()); + ClassicAssert.AreEqual(expected.Root, actual.Root); } public static void NotHasFlags(T expected, T actual) where T : Enum { - Assert.IsFalse(actual.HasFlag(expected)); + ClassicAssert.IsFalse(actual.HasFlag(expected)); } public static void HasFlags(T expected, T actual) where T : Enum { - Assert.IsTrue(actual.HasFlag(expected)); + ClassicAssert.IsTrue(actual.HasFlag(expected)); } public static void HasAllFlags(T actual, params T[] flags) where T : Enum { @@ -796,21 +797,21 @@ public static void HasAllFlags(T actual, params T[] flags) where T : Enum { public static void RegexMatch(string expected, string regexPattern, params Tuple[] expectedCaptures) { var regex = new Regex(regexPattern); var match = regex.Match(expected); - Assert.AreEqual(expected, match.Value); + ClassicAssert.AreEqual(expected, match.Value); foreach (var expectedCapture in expectedCaptures) { if (expectedCapture.Item2 == null) - Assert.IsFalse(match.Groups[expectedCapture.Item1].Success); + ClassicAssert.IsFalse(match.Groups[expectedCapture.Item1].Success); else - Assert.AreEqual(expectedCapture.Item2, match.Groups[expectedCapture.Item1]?.Value); + ClassicAssert.AreEqual(expectedCapture.Item2, match.Groups[expectedCapture.Item1]?.Value); } } public static void RegexNotMatch(string badInput, string regexPattern, params Tuple[] expectedCaptures) { var regex = new Regex(regexPattern); var match = regex.Match(badInput); - Assert.AreNotEqual(badInput, match.Value); + ClassicAssert.AreNotEqual(badInput, match.Value); if (expectedCaptures.Any()) - Assert.IsFalse(expectedCaptures.All(c => c.Item2 == match.Groups[c.Item1]?.Value)); + ClassicAssert.IsFalse(expectedCaptures.All(c => c.Item2 == match.Groups[c.Item1]?.Value)); } @@ -820,9 +821,9 @@ public static void AssertSame2DArrays(IEnumerable> expectedRow var preText = String.Format("{0}{1}{2}{0}", Environment.NewLine, Tools.NUnit.Convert2DArrayToString(expectedName, expectedRowsArr), Tools.NUnit.Convert2DArrayToString(actualName, actualRowsArr)); - Assert.AreEqual(expectedRowsArr.Count(), actualRowsArr.Count(), "{4}{0} has {1} row(s) but {2} has {3} row(s)", actualName, expectedRowsArr.Count(), expectedName, actualRowsArr.Count(), preText); + ClassicAssert.AreEqual(expectedRowsArr.Count(), actualRowsArr.Count(), "{4}{0} has {1} row(s) but {2} has {3} row(s)", actualName, expectedRowsArr.Count(), expectedName, actualRowsArr.Count(), preText); foreach (var rowExpectation in expectedRowsArr.WithDescriptions().Zip(actualRowsArr, Tuple.Create)) { - Assert.AreEqual(rowExpectation.Item1.Item.Count(), + ClassicAssert.AreEqual(rowExpectation.Item1.Item.Count(), rowExpectation.Item2.Count(), "{5}{0} row {1} had {2} column(s) but {3} row {1} had {4} column(s)", expectedName, @@ -832,7 +833,7 @@ public static void AssertSame2DArrays(IEnumerable> expectedRow rowExpectation.Item2.Count(), preText); foreach (var colExpectation in rowExpectation.Item1.Item.WithDescriptions().Zip(rowExpectation.Item2, Tuple.Create)) { - Assert.AreEqual(colExpectation.Item1.Item, + ClassicAssert.AreEqual(colExpectation.Item1.Item, colExpectation.Item2, "{6}{0} row {1} col {2} had value {3} but {4} row {1} col {2} had value {5}", expectedName, @@ -849,22 +850,22 @@ public static void AssertSame2DArrays(IEnumerable> expectedRow public static void ApproxEqual(System.DateTime expected, System.DateTime actual, TimeSpan? tolerance = null, string errorMessage = null) { var approxEqual = expected.ApproxEqual(actual, tolerance); if (!approxEqual) - Assert.Fail(errorMessage ?? "Dates not approximately equal.{0}Expected: {1:yyyy-MM-dd HH:mm:ss.fff}{0}Actual: {2:yyyy-MM-dd HH:mm:ss.fff}", Environment.NewLine, expected, actual); + ClassicAssert.Fail(errorMessage ?? ("Dates not approximately equal.{0}Expected: {1:yyyy-MM-dd HH:mm:ss.fff}{0}Actual: {2:yyyy-MM-dd HH:mm:ss.fff}").FormatWith(Environment.NewLine, expected, actual)); } public static void ApproxEqual(T expected, T actual, T tolerance, string message = null) { var lowerBound = Tools.OperatorTool.Subtract(expected, tolerance); var upperBound = Tools.OperatorTool.Add(expected, tolerance); var inRange = Tools.OperatorTool.LessThanOrEqual(lowerBound, actual) && Tools.OperatorTool.LessThanOrEqual(actual, upperBound); - Assert.IsTrue(inRange, message ?? $"Value '{actual}' was not approx equal to '{expected}' (tolerance '{tolerance}')"); + ClassicAssert.IsTrue(inRange, message ?? $"Value '{actual}' was not approx equal to '{expected}' (tolerance '{tolerance}')"); } public static void HasLoadedPages(PagedListBase list, params long[] pageNos) { - Assert.IsEmpty(list.Pages.Where(p => p.State == PageState.Loaded).Select(p => p.Number).Except(pageNos), "Unexpected pages were open"); + ClassicAssert.IsEmpty(list.Pages.Where(p => p.State == PageState.Loaded).Select(p => p.Number).Except(pageNos), "Unexpected pages were open"); } public static void HasDirtyPages(PagedListBase list, params long[] pageNos) { - Assert.IsEmpty(list.Pages.Where(p => p.Dirty).Select(p => p.Number).Except(pageNos), "Unexpected pages were dirty"); + ClassicAssert.IsEmpty(list.Pages.Where(p => p.Dirty).Select(p => p.Number).Except(pageNos), "Unexpected pages were dirty"); } } diff --git a/src/Hydrogen.NUnit/Hydrogen.NUnit.csproj b/src/Hydrogen.NUnit/Hydrogen.NUnit.csproj index c35ddba61..40e5c7143 100644 --- a/src/Hydrogen.NUnit/Hydrogen.NUnit.csproj +++ b/src/Hydrogen.NUnit/Hydrogen.NUnit.csproj @@ -1,7 +1,7 @@  - netstandard2.1 + net8.0 true latest @@ -13,7 +13,7 @@ - + diff --git a/src/Hydrogen.NUnit/NUnitTool.cs b/src/Hydrogen.NUnit/NUnitTool.cs index 8b97f121d..e5e8cc45d 100644 --- a/src/Hydrogen.NUnit/NUnitTool.cs +++ b/src/Hydrogen.NUnit/NUnitTool.cs @@ -11,6 +11,7 @@ using System.Text; using NUnit.Framework; using Hydrogen; +using NUnit.Framework.Legacy; namespace Tools; @@ -29,16 +30,16 @@ public static string Convert2DArrayToString(string header, IEnumerable(IEnumerable collection, string message = null) { if (!string.IsNullOrWhiteSpace(message)) - Assert.IsEmpty(collection, message); + ClassicAssert.IsEmpty(collection, message); else - Assert.IsEmpty(collection); + ClassicAssert.IsEmpty(collection); } public static void IsNotEmpty(IEnumerable collection, string message = null) { if (!string.IsNullOrWhiteSpace(message)) - Assert.IsNotEmpty(collection, message); + ClassicAssert.IsNotEmpty(collection, message); else - Assert.IsNotEmpty(collection); + ClassicAssert.IsNotEmpty(collection); } diff --git a/tests/Hydrogen.Communications.Tests/RPCComplexTests.cs b/tests/Hydrogen.Communications.Tests/RPCComplexTests.cs index 46f0582d6..8e1cd33a6 100644 --- a/tests/Hydrogen.Communications.Tests/RPCComplexTests.cs +++ b/tests/Hydrogen.Communications.Tests/RPCComplexTests.cs @@ -185,7 +185,7 @@ // //test for 5 seonds // int TestRoundCount = 5; // MiningManager.SimulateBlockCreation(TestRoundCount); -// Assert.AreEqual(RhMinerMock.Accepted, TestRoundCount * 4 / 2); +// ClassicAssert.AreEqual(RhMinerMock.Accepted, TestRoundCount * 4 / 2); // StopStratumServer(); // StopMiningManager(); diff --git a/tests/Hydrogen.Communications.Tests/RPCSimpleTests.cs b/tests/Hydrogen.Communications.Tests/RPCSimpleTests.cs index 4e5822674..103d003fe 100644 --- a/tests/Hydrogen.Communications.Tests/RPCSimpleTests.cs +++ b/tests/Hydrogen.Communications.Tests/RPCSimpleTests.cs @@ -249,115 +249,115 @@ // ApiServiceManager.RegisterService(apiTest); // //test GetService -// Assert.AreNotEqual(ApiServiceManager.GetService("ClassMember"), null); -// Assert.AreNotEqual(ApiServiceManager.GetService("classmember"), null); -// Assert.AreEqual(ApiServiceManager.GetService("Api"), apiTest); -// Assert.AreEqual(ApiServiceManager.GetService("_VOID_"), null); -// Assert.AreNotEqual(ApiServiceManager.GetService("array"), null); +// ClassicAssert.AreNotEqual(ApiServiceManager.GetService("ClassMember"), null); +// ClassicAssert.AreNotEqual(ApiServiceManager.GetService("classmember"), null); +// ClassicAssert.AreEqual(ApiServiceManager.GetService("Api"), apiTest); +// ClassicAssert.AreEqual(ApiServiceManager.GetService("_VOID_"), null); +// ClassicAssert.AreNotEqual(ApiServiceManager.GetService("array"), null); // ApiService service = ApiServiceManager.GetService("classmember"); // //Test GetServiceFromMethod -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("classmember.AddValue"), service); -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("classmember.addvalue"), service); -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("classmember.ExplicitArguments"), service); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("classmember.AddValue"), service); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("classmember.addvalue"), service); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("classmember.ExplicitArguments"), service); -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("api.AddValue"), apiTest); -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("api.addvalue"), apiTest); -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("api.ExplicitArguments"), apiTest); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("api.AddValue"), apiTest); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("api.addvalue"), apiTest); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("api.ExplicitArguments"), apiTest); // //Test ApiService -// Assert.IsFalse(service.IsApi(classMemberTest)); -// Assert.IsTrue(service.IsApi(classMemberTest.classMember)); -// Assert.IsFalse(service.IsApi(this)); -// Assert.AreNotEqual(service.GetMethod("classmember.AddValue"), null); -// Assert.AreEqual(service.GetMethod("AddValue"), null); -// Assert.AreEqual(service.GetMethod("_VOID_"), null); +// ClassicAssert.IsFalse(service.IsApi(classMemberTest)); +// ClassicAssert.IsTrue(service.IsApi(classMemberTest.classMember)); +// ClassicAssert.IsFalse(service.IsApi(this)); +// ClassicAssert.AreNotEqual(service.GetMethod("classmember.AddValue"), null); +// ClassicAssert.AreEqual(service.GetMethod("AddValue"), null); +// ClassicAssert.AreEqual(service.GetMethod("_VOID_"), null); // //Test MethodDescriptors // var method = service.GetMethod("classmember.ExplicitArguments"); -// Assert.AreEqual(method.MethodName, "classmember.explicitarguments"); -// Assert.AreEqual(method.Arguments.Count, 1); -// Assert.AreEqual(method.Arguments[0].Item1, "arg1"); -// Assert.AreEqual(method.Arguments[0].Item2, typeof(uint)); -// Assert.AreEqual(method.ReturnType, typeof(void)); +// ClassicAssert.AreEqual(method.MethodName, "classmember.explicitarguments"); +// ClassicAssert.AreEqual(method.Arguments.Count, 1); +// ClassicAssert.AreEqual(method.Arguments[0].Item1, "arg1"); +// ClassicAssert.AreEqual(method.Arguments[0].Item2, typeof(uint)); +// ClassicAssert.AreEqual(method.ReturnType, typeof(void)); // method = service.GetMethod("classmember.AddValue"); -// Assert.AreEqual(method.MethodName, "classmember.addvalue"); -// Assert.AreEqual(method.Arguments.Count, 2); -// Assert.AreEqual(method.Arguments[0].Item1, "a"); -// Assert.AreEqual(method.Arguments[0].Item2, typeof(int)); -// Assert.AreEqual(method.Arguments[1].Item1, "b"); -// Assert.AreEqual(method.Arguments[1].Item2, typeof(int)); -// Assert.AreEqual(method.ReturnType, typeof(int)); +// ClassicAssert.AreEqual(method.MethodName, "classmember.addvalue"); +// ClassicAssert.AreEqual(method.Arguments.Count, 2); +// ClassicAssert.AreEqual(method.Arguments[0].Item1, "a"); +// ClassicAssert.AreEqual(method.Arguments[0].Item2, typeof(int)); +// ClassicAssert.AreEqual(method.Arguments[1].Item1, "b"); +// ClassicAssert.AreEqual(method.Arguments[1].Item2, typeof(int)); +// ClassicAssert.AreEqual(method.ReturnType, typeof(int)); // //Test api MethodDescriptors // service = ApiServiceManager.GetService("api"); // method = service.GetMethod("Api.AddStrings"); -// Assert.AreEqual(method.MethodName, "api.addstrings"); -// Assert.AreEqual(method.Arguments.Count, 2); -// Assert.AreEqual(method.Arguments[0].Item1, "s1"); -// Assert.AreEqual(method.Arguments[0].Item2, typeof(string)); -// Assert.AreEqual(method.Arguments[1].Item1, "s2"); -// Assert.AreEqual(method.Arguments[1].Item2, typeof(string)); -// Assert.AreEqual(method.ReturnType, typeof(string)); +// ClassicAssert.AreEqual(method.MethodName, "api.addstrings"); +// ClassicAssert.AreEqual(method.Arguments.Count, 2); +// ClassicAssert.AreEqual(method.Arguments[0].Item1, "s1"); +// ClassicAssert.AreEqual(method.Arguments[0].Item2, typeof(string)); +// ClassicAssert.AreEqual(method.Arguments[1].Item1, "s2"); +// ClassicAssert.AreEqual(method.Arguments[1].Item2, typeof(string)); +// ClassicAssert.AreEqual(method.ReturnType, typeof(string)); // method = service.GetMethod("Api.Add2Diff"); -// Assert.AreEqual(method.MethodName, "api.add2diff"); -// Assert.AreEqual(method.Arguments.Count, 2); -// Assert.AreEqual(method.Arguments[0].Item1, "arg1"); -// Assert.AreEqual(method.Arguments[0].Item2, typeof(uint)); -// Assert.AreEqual(method.Arguments[1].Item1, "arg2"); -// Assert.AreEqual(method.Arguments[1].Item2, typeof(int)); -// Assert.AreEqual(method.ReturnType, typeof(uint)); +// ClassicAssert.AreEqual(method.MethodName, "api.add2diff"); +// ClassicAssert.AreEqual(method.Arguments.Count, 2); +// ClassicAssert.AreEqual(method.Arguments[0].Item1, "arg1"); +// ClassicAssert.AreEqual(method.Arguments[0].Item2, typeof(uint)); +// ClassicAssert.AreEqual(method.Arguments[1].Item1, "arg2"); +// ClassicAssert.AreEqual(method.Arguments[1].Item2, typeof(int)); +// ClassicAssert.AreEqual(method.ReturnType, typeof(uint)); // //Test anonymous api // var anonService = ApiServiceManager.GetService(""); -// Assert.AreNotEqual(ApiServiceManager.GetService(""), null); -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("getworkitem"), anonService); -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("getwork"), anonService); -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("GetMoreWorkItem"), anonService); -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("GetMoreWork"), anonService); +// ClassicAssert.AreNotEqual(ApiServiceManager.GetService(""), null); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("getworkitem"), anonService); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("getwork"), anonService); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("GetMoreWorkItem"), anonService); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("GetMoreWork"), anonService); // method = anonService.GetMethod("GetWork"); -// Assert.AreEqual(method.MethodName, "getwork"); -// Assert.AreEqual(method.Arguments.Count, 2); -// Assert.AreEqual(method.Arguments[0].Item1, "user"); -// Assert.AreEqual(method.Arguments[0].Item2, typeof(string)); -// Assert.AreEqual(method.Arguments[1].Item1, "nonce1"); -// Assert.AreEqual(method.Arguments[1].Item2, typeof(string)); -// Assert.AreEqual(method.ReturnType, typeof(string)); +// ClassicAssert.AreEqual(method.MethodName, "getwork"); +// ClassicAssert.AreEqual(method.Arguments.Count, 2); +// ClassicAssert.AreEqual(method.Arguments[0].Item1, "user"); +// ClassicAssert.AreEqual(method.Arguments[0].Item2, typeof(string)); +// ClassicAssert.AreEqual(method.Arguments[1].Item1, "nonce1"); +// ClassicAssert.AreEqual(method.Arguments[1].Item2, typeof(string)); +// ClassicAssert.AreEqual(method.ReturnType, typeof(string)); // method = anonService.GetMethod("GetMoreWork"); -// Assert.AreEqual(method.MethodName, "getmorework"); -// Assert.AreEqual(method.Arguments.Count, 2); -// Assert.AreEqual(method.Arguments[0].Item1, "w"); -// Assert.AreEqual(method.Arguments[0].Item2, typeof(string)); -// Assert.AreEqual(method.Arguments[1].Item1, "n"); -// Assert.AreEqual(method.Arguments[1].Item2, typeof(string)); -// Assert.AreEqual(method.ReturnType, typeof(string)); +// ClassicAssert.AreEqual(method.MethodName, "getmorework"); +// ClassicAssert.AreEqual(method.Arguments.Count, 2); +// ClassicAssert.AreEqual(method.Arguments[0].Item1, "w"); +// ClassicAssert.AreEqual(method.Arguments[0].Item2, typeof(string)); +// ClassicAssert.AreEqual(method.Arguments[1].Item1, "n"); +// ClassicAssert.AreEqual(method.Arguments[1].Item2, typeof(string)); +// ClassicAssert.AreEqual(method.ReturnType, typeof(string)); // method = ApiServiceManager.GetService("array").GetMethod("array.AddArrayUInt"); -// Assert.AreEqual(method.MethodName, "array.addarrayuint"); -// Assert.AreEqual(method.Arguments.Count, 2); -// Assert.AreEqual(method.Arguments[0].Item1, "a"); -// Assert.AreEqual(method.Arguments[0].Item2, typeof(uint)); -// Assert.AreEqual(method.Arguments[1].Item1, "b"); -// Assert.AreEqual(method.Arguments[1].Item2, typeof(uint[])); -// Assert.AreEqual(method.ReturnType, typeof(uint[])); +// ClassicAssert.AreEqual(method.MethodName, "array.addarrayuint"); +// ClassicAssert.AreEqual(method.Arguments.Count, 2); +// ClassicAssert.AreEqual(method.Arguments[0].Item1, "a"); +// ClassicAssert.AreEqual(method.Arguments[0].Item2, typeof(uint)); +// ClassicAssert.AreEqual(method.Arguments[1].Item1, "b"); +// ClassicAssert.AreEqual(method.Arguments[1].Item2, typeof(uint[])); +// ClassicAssert.AreEqual(method.ReturnType, typeof(uint[])); // //test unreg+reg+unred // ApiServiceManager.UnregisterService("classmember"); -// Assert.AreEqual(ApiServiceManager.GetService("ClassMember"), null); +// ClassicAssert.AreEqual(ApiServiceManager.GetService("ClassMember"), null); // ApiServiceManager.UnregisterService("classmember"); -// Assert.AreEqual(ApiServiceManager.GetService("ClassMember"), null); +// ClassicAssert.AreEqual(ApiServiceManager.GetService("ClassMember"), null); // ApiServiceManager.UnregisterService("api"); -// Assert.AreEqual(ApiServiceManager.GetService("api"), null); +// ClassicAssert.AreEqual(ApiServiceManager.GetService("api"), null); // ApiServiceManager.RegisterService(apiTest); -// Assert.AreEqual(ApiServiceManager.GetServiceFromMethod("api.AddValue"), apiTest); +// ClassicAssert.AreEqual(ApiServiceManager.GetServiceFromMethod("api.AddValue"), apiTest); // ApiServiceManager.UnregisterService(apiTest as object); -// Assert.AreEqual(ApiServiceManager.GetService("api"), null); +// ClassicAssert.AreEqual(ApiServiceManager.GetService("api"), null); // ApiServiceManager.UnregisterService(""); // ApiServiceManager.UnregisterService(anonymousAPI1); @@ -414,87 +414,87 @@ // enumVal2 = FreeEnum.Second, // dictionary = new Dictionary { { "zzz", 111 }, { "YYY", 222 }, { "TTT", 333 } }, // }); -// Assert.AreEqual(to.iVal, 199 + 1); -// Assert.AreEqual(to.fArray, new float[] { 8, 1 }); -// Assert.AreEqual(to.sVal, "allo1"); -// Assert.AreEqual(to.enumVal, FreeEnum.Third); -// Assert.AreEqual(to.enumVal2, FreeEnum.Second); -// Assert.AreEqual(to.bytesArray, new byte[] { 9, 2, 3, 8, 9, 4, 5, 6, 7, 8, 1, 9, 3, 7, 6, 5 }); -// Assert.AreEqual(to.dictionary, new Dictionary { { "zzz", 111 }, { "YYY", 222 }, { "TTT", 333 } }); -// Assert.AreEqual(client.RemoteCall>("classMember.GetTestDictionary", new Dictionary { { "a", 8 }, { "b", 10 } }), new Dictionary { { "8", 10 }, { "88", 20 }, { "888", 30 } }); -// Assert.AreEqual(client.RemoteCall[]>("classMember.GetTestArrayOfTuple", "x", 1), new Tuple[] { new Tuple("x", 1), new Tuple("xx", 2), new Tuple("xxx", 3) }); +// ClassicAssert.AreEqual(to.iVal, 199 + 1); +// ClassicAssert.AreEqual(to.fArray, new float[] { 8, 1 }); +// ClassicAssert.AreEqual(to.sVal, "allo1"); +// ClassicAssert.AreEqual(to.enumVal, FreeEnum.Third); +// ClassicAssert.AreEqual(to.enumVal2, FreeEnum.Second); +// ClassicAssert.AreEqual(to.bytesArray, new byte[] { 9, 2, 3, 8, 9, 4, 5, 6, 7, 8, 1, 9, 3, 7, 6, 5 }); +// ClassicAssert.AreEqual(to.dictionary, new Dictionary { { "zzz", 111 }, { "YYY", 222 }, { "TTT", 333 } }); +// ClassicAssert.AreEqual(client.RemoteCall>("classMember.GetTestDictionary", new Dictionary { { "a", 8 }, { "b", 10 } }), new Dictionary { { "8", 10 }, { "88", 20 }, { "888", 30 } }); +// ClassicAssert.AreEqual(client.RemoteCall[]>("classMember.GetTestArrayOfTuple", "x", 1), new Tuple[] { new Tuple("x", 1), new Tuple("xx", 2), new Tuple("xxx", 3) }); // //Test array of random types -// Assert.AreEqual(client.RemoteCall("array.ToArrayOfArrayOfIntAndStrings", 13, "Bob"), new object[][] { new object[] { 14, "Bob" }, new object[] { "Bob", 15 } }); -// Assert.AreEqual(client.RemoteCall("array.ToByteArray", 9, new byte[] { (byte)0, (byte)10, (byte)20, (byte)30 }), new byte[] { (byte)9, (byte)19, (byte)29, (byte)39 }); -// Assert.AreEqual(client.RemoteCall("ClassMember.GetObjectWithBytesArray", new TestObjectWithBytesArray { bytesArray = new byte[] { 1, 3, 7, 9 } }).bytesArray, new byte[] { 9, 7, 3, 1 }); +// ClassicAssert.AreEqual(client.RemoteCall("array.ToArrayOfArrayOfIntAndStrings", 13, "Bob"), new object[][] { new object[] { 14, "Bob" }, new object[] { "Bob", 15 } }); +// ClassicAssert.AreEqual(client.RemoteCall("array.ToByteArray", 9, new byte[] { (byte)0, (byte)10, (byte)20, (byte)30 }), new byte[] { (byte)9, (byte)19, (byte)29, (byte)39 }); +// ClassicAssert.AreEqual(client.RemoteCall("ClassMember.GetObjectWithBytesArray", new TestObjectWithBytesArray { bytesArray = new byte[] { 1, 3, 7, 9 } }).bytesArray, new byte[] { 9, 7, 3, 1 }); // TestObject[] toa = client.RemoteCall("ClassMember.GetTestObjectArray", new TestObject { iVal = 199, fArray = new float[] { 8 }, sVal = "allo" }); -// Assert.AreEqual(toa[0].iVal, 199 + 1); -// Assert.AreEqual(toa[0].fArray, new float[] { 8, 1 }); -// Assert.AreEqual(toa[0].sVal, "allo1"); -// Assert.AreEqual(toa[1].iVal, 199 + 2); -// Assert.AreEqual(toa[1].fArray, new float[] { 8, 2 }); -// Assert.AreEqual(toa[1].sVal, "allo2"); +// ClassicAssert.AreEqual(toa[0].iVal, 199 + 1); +// ClassicAssert.AreEqual(toa[0].fArray, new float[] { 8, 1 }); +// ClassicAssert.AreEqual(toa[0].sVal, "allo1"); +// ClassicAssert.AreEqual(toa[1].iVal, 199 + 2); +// ClassicAssert.AreEqual(toa[1].fArray, new float[] { 8, 2 }); +// ClassicAssert.AreEqual(toa[1].sVal, "allo2"); // //Test array in return values -// Assert.AreEqual(client.RemoteCall("array.AddArrayString", "A", new string[] { "1", "3", "7", "9" }), new string[] { "A.1", "A.3", "A.7", "A.9" }); -// Assert.AreEqual(client.RemoteCall("array.AddArrayInt", 10, new int[] { 1, 3, 7, 9 }), new int[] { 11, 13, 17, 19 }); -// Assert.AreEqual(client.RemoteCall("array.AddArrayUInt", 100, new int[] { 1, 3, 7, 9 }), new uint[] { 101, 103, 107, 109 }); -// Assert.AreEqual(client.RemoteCall("array.AddArrayFloat", 10.5, new float[] { 1, 3, 7, 9 }), new float[] { 11.5f, 13.5f, 17.5f, 19.5f }); -// Assert.AreEqual(client.RemoteCall("array.AddArrayDouble", 100.8, new double[] { 1, 3, 7, 9 }), new double[] { 101.8, 103.8, 107.8, 109.8 }); -// Assert.AreEqual(client.RemoteCall("array.ToArrayString", "Sponge", "Bob"), new string[] { "Sponge", "Bob" }); -// Assert.AreEqual(client.RemoteCall("array.ToArrayDouble", 666.777, 88.99), new double[] { 666.777, 88.99 }); -// Assert.AreEqual(client.RemoteCall("array.ToArrayFloat", 123.555, 12.12), new float[] { 123.555f, 12.12f }); -// Assert.AreEqual(client.RemoteCall("array.ToArrayUInt", 422, 5), new uint[] { 422, 5 }); -// Assert.AreEqual(client.RemoteCall("array.ToArrayInt", 123, 1), new uint[] { 123, 1 }); +// ClassicAssert.AreEqual(client.RemoteCall("array.AddArrayString", "A", new string[] { "1", "3", "7", "9" }), new string[] { "A.1", "A.3", "A.7", "A.9" }); +// ClassicAssert.AreEqual(client.RemoteCall("array.AddArrayInt", 10, new int[] { 1, 3, 7, 9 }), new int[] { 11, 13, 17, 19 }); +// ClassicAssert.AreEqual(client.RemoteCall("array.AddArrayUInt", 100, new int[] { 1, 3, 7, 9 }), new uint[] { 101, 103, 107, 109 }); +// ClassicAssert.AreEqual(client.RemoteCall("array.AddArrayFloat", 10.5, new float[] { 1, 3, 7, 9 }), new float[] { 11.5f, 13.5f, 17.5f, 19.5f }); +// ClassicAssert.AreEqual(client.RemoteCall("array.AddArrayDouble", 100.8, new double[] { 1, 3, 7, 9 }), new double[] { 101.8, 103.8, 107.8, 109.8 }); +// ClassicAssert.AreEqual(client.RemoteCall("array.ToArrayString", "Sponge", "Bob"), new string[] { "Sponge", "Bob" }); +// ClassicAssert.AreEqual(client.RemoteCall("array.ToArrayDouble", 666.777, 88.99), new double[] { 666.777, 88.99 }); +// ClassicAssert.AreEqual(client.RemoteCall("array.ToArrayFloat", 123.555, 12.12), new float[] { 123.555f, 12.12f }); +// ClassicAssert.AreEqual(client.RemoteCall("array.ToArrayUInt", 422, 5), new uint[] { 422, 5 }); +// ClassicAssert.AreEqual(client.RemoteCall("array.ToArrayInt", 123, 1), new uint[] { 123, 1 }); // //tsts normal calls with return value -// Assert.AreEqual(client.RemoteCall("ClassMember.addint", 11, -1), 10); -// Assert.AreEqual(client.RemoteCall("ClassMember.AddValue", 11, 2), 13); -// Assert.AreEqual(client.RemoteCall("ClassMember.AddUInt", 5, 5), 10); -// Assert.AreEqual(client.RemoteCall("ClassMember.AddFloat", 198.0099999, 0.0000001), (float)198.01); -// Assert.AreEqual(client.RemoteCall("ClassMember.AddDouble", (double)float.MaxValue, ((double)float.MaxValue) / 2), (((double)float.MaxValue) + ((double)float.MaxValue) / 2)); -// Assert.AreEqual(client.RemoteCall("api.addstrings", "ham", "burger"), "hamburger"); -// Assert.AreEqual(client.RemoteCall("api.Add2Diff", 199, -9), 190); +// ClassicAssert.AreEqual(client.RemoteCall("ClassMember.addint", 11, -1), 10); +// ClassicAssert.AreEqual(client.RemoteCall("ClassMember.AddValue", 11, 2), 13); +// ClassicAssert.AreEqual(client.RemoteCall("ClassMember.AddUInt", 5, 5), 10); +// ClassicAssert.AreEqual(client.RemoteCall("ClassMember.AddFloat", 198.0099999, 0.0000001), (float)198.01); +// ClassicAssert.AreEqual(client.RemoteCall("ClassMember.AddDouble", (double)float.MaxValue, ((double)float.MaxValue) / 2), (((double)float.MaxValue) + ((double)float.MaxValue) / 2)); +// ClassicAssert.AreEqual(client.RemoteCall("api.addstrings", "ham", "burger"), "hamburger"); +// ClassicAssert.AreEqual(client.RemoteCall("api.Add2Diff", 199, -9), 190); // //Test method with no return value and no args // classMemberTest.classMember.TestValue = 7; // client.RemoteCall("ClassMember.ExplicitArguments", 2); -// Assert.AreEqual(classMemberTest.classMember.TestValue, 2); +// ClassicAssert.AreEqual(classMemberTest.classMember.TestValue, 2); // classMemberTest.classMember.TestValue = 17; // client.RemoteCall("ClassMember.ExplicitArguments", 12); -// Assert.AreEqual(classMemberTest.classMember.TestValue, 12); +// ClassicAssert.AreEqual(classMemberTest.classMember.TestValue, 12); // classMemberTest.classMember.TestValue = 8; -// Assert.AreEqual(client.RemoteCall("ClassMember.NoArgsWithRet"), 987654321); -// Assert.AreEqual(classMemberTest.classMember.TestValue, 123456789); +// ClassicAssert.AreEqual(client.RemoteCall("ClassMember.NoArgsWithRet"), 987654321); +// ClassicAssert.AreEqual(classMemberTest.classMember.TestValue, 123456789); // classMemberTest.classMember.TestValue = 9; // client.RemoteCall("ClassMember.NoArgs"); -// Assert.AreEqual(classMemberTest.classMember.TestValue, 77777777); +// ClassicAssert.AreEqual(classMemberTest.classMember.TestValue, 77777777); // //Test int overflow -// Assert.AreEqual(client.RemoteCall("ClassMember.AddUInt", System.UInt32.MaxValue, 2), 1); +// ClassicAssert.AreEqual(client.RemoteCall("ClassMember.AddUInt", System.UInt32.MaxValue, 2), 1); // //test anonymous/nameless api -// Assert.AreEqual(client.RemoteCall("getwork", "rad", "ical"), "RAD.ICAL"); -// Assert.AreEqual(client.RemoteCall("getmorework", "Abs", "Olut"), "ABS.OLUT"); +// ClassicAssert.AreEqual(client.RemoteCall("getwork", "rad", "ical"), "RAD.ICAL"); +// ClassicAssert.AreEqual(client.RemoteCall("getmorework", "Abs", "Olut"), "ABS.OLUT"); // //test enum -// Assert.AreEqual(client.RemoteCall("api.TestEnum", FreeEnum.First), TestApi.FixedEnum.Big); -// Assert.AreEqual(client.RemoteCall("api.TestEnum", FreeEnum.Second), TestApi.FixedEnum.Medium); -// Assert.AreEqual(client.RemoteCall("api.TestEnum", FreeEnum.Third), TestApi.FixedEnum.Small); +// ClassicAssert.AreEqual(client.RemoteCall("api.TestEnum", FreeEnum.First), TestApi.FixedEnum.Big); +// ClassicAssert.AreEqual(client.RemoteCall("api.TestEnum", FreeEnum.Second), TestApi.FixedEnum.Medium); +// ClassicAssert.AreEqual(client.RemoteCall("api.TestEnum", FreeEnum.Third), TestApi.FixedEnum.Small); // //Test int as hex // var ohx = client.RemoteCall("api.GetTestObjectHex"); -// Assert.AreEqual(ohx.hexUInt, 999999); -// Assert.AreEqual(ohx.hexInt, 88888); -// Assert.AreEqual(ohx.hexInt64, 0x75553333999CCCC1); -// Assert.AreEqual(ohx.hexUInt64, 0xFFFFAAAABBBB3333); +// ClassicAssert.AreEqual(ohx.hexUInt, 999999); +// ClassicAssert.AreEqual(ohx.hexInt, 88888); +// ClassicAssert.AreEqual(ohx.hexInt64, 0x75553333999CCCC1); +// ClassicAssert.AreEqual(ohx.hexUInt64, 0xFFFFAAAABBBB3333); // var ohx2 = client.RemoteCall("api.GetTestObjectHex2", new TestObjectHex { hexUInt = 1234567891, hexInt = 2147483641, hexInt64 = 163245617943825, hexUInt64 = 0xFFFFFFFFFFFFFFF }); -// Assert.AreEqual(ohx2.hexUInt, 1234567891 + 1); -// Assert.AreEqual(ohx2.hexInt, 2147483641 + 1); -// Assert.AreEqual(ohx2.hexInt64, 163245617943825 + 1); -// Assert.AreEqual(ohx2.hexUInt64, 0xFFFFFFFFFFFFFFF + 1); +// ClassicAssert.AreEqual(ohx2.hexUInt, 1234567891 + 1); +// ClassicAssert.AreEqual(ohx2.hexInt, 2147483641 + 1); +// ClassicAssert.AreEqual(ohx2.hexInt64, 163245617943825 + 1); +// ClassicAssert.AreEqual(ohx2.hexUInt64, 0xFFFFFFFFFFFFFFF + 1); // //Test batch calls // classMemberTest.classMember.TestValue = 156; @@ -512,46 +512,46 @@ // batch.Call("ClassMember.GetTestObjectArray", new TestObject { iVal = 199, fArray = new float[] { 8 }, sVal = "allo" }); // object[] batchResult = client.RemoteCall(batch); // //eval -// Assert.AreEqual(batchResult[0], 10); -// Assert.AreEqual(batchResult[1], 13); -// Assert.AreEqual(batchResult[2], 10); -// Assert.AreEqual(batchResult[3], (float)198.01); -// Assert.AreEqual(batchResult[4], (((double)float.MaxValue) + ((double)float.MaxValue) / 2) ); -// Assert.AreEqual(batchResult[5], "hamburger"); -// Assert.AreEqual(batchResult[6], 190); -// Assert.AreEqual(classMemberTest.classMember.TestValue, 877); -// Assert.AreEqual(batchResult[8], new object[][] { new object[] { 14, "Bob" }, new object[] { "Bob", 15 } }); -// Assert.AreEqual(batchResult[9], new float[] { 11.5f, 13.5f, 17.5f, 19.5f }); +// ClassicAssert.AreEqual(batchResult[0], 10); +// ClassicAssert.AreEqual(batchResult[1], 13); +// ClassicAssert.AreEqual(batchResult[2], 10); +// ClassicAssert.AreEqual(batchResult[3], (float)198.01); +// ClassicAssert.AreEqual(batchResult[4], (((double)float.MaxValue) + ((double)float.MaxValue) / 2) ); +// ClassicAssert.AreEqual(batchResult[5], "hamburger"); +// ClassicAssert.AreEqual(batchResult[6], 190); +// ClassicAssert.AreEqual(classMemberTest.classMember.TestValue, 877); +// ClassicAssert.AreEqual(batchResult[8], new object[][] { new object[] { 14, "Bob" }, new object[] { "Bob", 15 } }); +// ClassicAssert.AreEqual(batchResult[9], new float[] { 11.5f, 13.5f, 17.5f, 19.5f }); // var objArray = (TestObject[])batchResult[10]; -// Assert.AreEqual(objArray[0].iVal, 199 + 1); -// Assert.AreEqual(objArray[0].fArray, new float[] { 8, 1 }); -// Assert.AreEqual(objArray[0].sVal, "allo1"); -// Assert.AreEqual(objArray[1].iVal, 199 + 2); -// Assert.AreEqual(objArray[1].fArray, new float[] { 8, 2 }); -// Assert.AreEqual(objArray[1].sVal, "allo2"); +// ClassicAssert.AreEqual(objArray[0].iVal, 199 + 1); +// ClassicAssert.AreEqual(objArray[0].fArray, new float[] { 8, 1 }); +// ClassicAssert.AreEqual(objArray[0].sVal, "allo1"); +// ClassicAssert.AreEqual(objArray[1].iVal, 199 + 2); +// ClassicAssert.AreEqual(objArray[1].fArray, new float[] { 8, 2 }); +// ClassicAssert.AreEqual(objArray[1].sVal, "allo2"); // //Test "Arguments exception cought : {ex.ToString()}" / Wrong argument counts -// Assert.AreEqual(TestRpcException(client, "ClassMember.AddValue", new object[] { 1, 1, 1 }), "RPC error -3: Wrong argument count in method ClassMember.AddValue."); -// Assert.AreEqual(TestRpcException(client, "ClassMember.NoArgs", new object[] { 1, 1, 1 }), "RPC error -3: Wrong argument count in method ClassMember.NoArgs."); +// ClassicAssert.AreEqual(TestRpcException(client, "ClassMember.AddValue", new object[] { 1, 1, 1 }), "RPC error -3: Wrong argument count in method ClassMember.AddValue."); +// ClassicAssert.AreEqual(TestRpcException(client, "ClassMember.NoArgs", new object[] { 1, 1, 1 }), "RPC error -3: Wrong argument count in method ClassMember.NoArgs."); // //Test "The method {methodName}does not exist" -// Assert.AreEqual(TestRpcException(client, "_VOID_", new object[] { 1 }), "RPC error -2: The method _VOID_ does not exist."); +// ClassicAssert.AreEqual(TestRpcException(client, "_VOID_", new object[] { 1 }), "RPC error -2: The method _VOID_ does not exist."); // //Test "Wrong argument type in {methodName}. Arguments are {sig}" -// Assert.AreEqual(TestRpcException(client, "ClassMember.AddValue", new object[] { "s", "s" }), "RPC error -5: Wrong argument type in method ClassMember.AddValue."); +// ClassicAssert.AreEqual(TestRpcException(client, "ClassMember.AddValue", new object[] { "s", "s" }), "RPC error -5: Wrong argument type in method ClassMember.AddValue."); // //Test "RPC method ClassMember.NoArgs does not return a value. Use non-templated RemoteCall to call this method" -// Assert.AreEqual(TestRpcException(client, "ClassMember.NoArgs", new object[] { }), "RPC method ClassMember.NoArgs does not return a value. Use non-templated RemoteCall to call this method"); +// ClassicAssert.AreEqual(TestRpcException(client, "ClassMember.NoArgs", new object[] { }), "RPC method ClassMember.NoArgs does not return a value. Use non-templated RemoteCall to call this method"); // //Test BATCH "Arguments exception cought : {ex.ToString()}" / Wrong argument counts -// Assert.AreEqual(TestRpcExceptionBatch(client, "ClassMember.AddValue", new object[] { 1, 1, 1 }), "RPC error -3: Wrong argument count in method ClassMember.AddValue."); -// Assert.AreEqual(TestRpcExceptionBatch(client, "ClassMember.NoArgs", new object[] { 1, 1, 1 }), "RPC error -3: Wrong argument count in method ClassMember.NoArgs."); +// ClassicAssert.AreEqual(TestRpcExceptionBatch(client, "ClassMember.AddValue", new object[] { 1, 1, 1 }), "RPC error -3: Wrong argument count in method ClassMember.AddValue."); +// ClassicAssert.AreEqual(TestRpcExceptionBatch(client, "ClassMember.NoArgs", new object[] { 1, 1, 1 }), "RPC error -3: Wrong argument count in method ClassMember.NoArgs."); // //Test BATCH "The method {methodName}does not exist" -// Assert.AreEqual(TestRpcExceptionBatch(client, "_VOID_", new object[] { 1 }), "RPC error -2: The method _VOID_ does not exist."); +// ClassicAssert.AreEqual(TestRpcExceptionBatch(client, "_VOID_", new object[] { 1 }), "RPC error -2: The method _VOID_ does not exist."); // //Test BATCH "Wrong argument type in {methodName}. Arguments are {sig}" -// Assert.AreEqual(TestRpcExceptionBatch(client, "ClassMember.AddValue", new object[] { "s", "s" }), "RPC error -5: Wrong argument type in method ClassMember.AddValue."); +// ClassicAssert.AreEqual(TestRpcExceptionBatch(client, "ClassMember.AddValue", new object[] { "s", "s" }), "RPC error -5: Wrong argument type in method ClassMember.AddValue."); // //Test BATCH "RPC method ClassMember.NoArgs does not return a value. Use non-templated RemoteCall to call this method" -// Assert.AreEqual(TestRpcExceptionBatch(client, "ClassMember.NoArgs", new object[] { }), "null"); +// ClassicAssert.AreEqual(TestRpcExceptionBatch(client, "ClassMember.NoArgs", new object[] { }), "null"); // } catch (Exception e) { @@ -608,21 +608,21 @@ // //test HexadecimalValueConverterReader reading/writing // string curlRes = curl(" {\"jsonrpc\":\"2.0\",\"method\":\"api.GetTestObjectHex2\",\"params\":[{\"hexInt\":0x7ffffff9,\"hexUInt\":\"0x499602d3\",\"hexUInt64\":\"0xfffffffffffffff\",\"hexInt64\":\"0x947895119511\"}],\"id\":2} \n "); // JsonResponse jres = JsonConvert.DeserializeObject(curlRes, new JsonSerializerSettings { Converters = { { new ByteArrayHexConverter() } } }); -// Assert.AreEqual(jres.Error, null); +// ClassicAssert.AreEqual(jres.Error, null); // int hexInt = (int)(jres.Result as JObject)["hexInt"]; // uint hexUInt = (uint)(jres.Result as JObject)["hexUInt"]; // Int64 hexInt64 = (Int64)(jres.Result as JObject)["hexInt64"]; // UInt64 hexUInt64 = (UInt64)(jres.Result as JObject)["hexUInt64"]; -// Assert.AreEqual(hexInt, 0x7ffffff9 + 1); -// Assert.AreEqual(hexUInt, 0x499602d3 + 1); -// Assert.AreEqual(hexInt64, 0x947895119511 + 1); -// Assert.AreEqual(hexUInt64, 0xfffffffffffffff + 1); +// ClassicAssert.AreEqual(hexInt, 0x7ffffff9 + 1); +// ClassicAssert.AreEqual(hexUInt, 0x499602d3 + 1); +// ClassicAssert.AreEqual(hexInt64, 0x947895119511 + 1); +// ClassicAssert.AreEqual(hexUInt64, 0xfffffffffffffff + 1); // //test Newtonsoft.Json implicit hex reading // curlRes = curl("\n{ \"jsonrpc\":\"2.0\",\"method\":\"ClassMember.addint\",\"params\":[0xd,7],\"id\":1}\n"); // jres = JsonConvert.DeserializeObject(curlRes, new JsonSerializerSettings { Converters = { { new ByteArrayHexConverter() } } }); -// Assert.AreEqual(jres.Error, null); -// Assert.AreEqual((long)jres.Result, 20); +// ClassicAssert.AreEqual(jres.Error, null); +// ClassicAssert.AreEqual((long)jres.Result, 20); // } // catch (Exception e) // { @@ -677,7 +677,7 @@ // var socket = new TcpClient("127.0.0.1", 27001); // socket.Client.ReceiveTimeout = 5000; // var client = new JsonRpcClient(new TcpEndPoint(socket), JsonRpcConfig.Default); -// Assert.AreEqual(client.RemoteCall("api.Add2Diff", 199, -9), 190); +// ClassicAssert.AreEqual(client.RemoteCall("api.Add2Diff", 199, -9), 190); // Thread.Sleep(250); // } // catch (Exception e) { diff --git a/tests/Hydrogen.CryptoEx.Tests/Bip340SchnorrTest.cs b/tests/Hydrogen.CryptoEx.Tests/Bip340SchnorrTest.cs index a9bc3c1b2..92a49e75e 100644 --- a/tests/Hydrogen.CryptoEx.Tests/Bip340SchnorrTest.cs +++ b/tests/Hydrogen.CryptoEx.Tests/Bip340SchnorrTest.cs @@ -14,6 +14,7 @@ using System.IO; using System.Linq; using Hydrogen.CryptoEx.EC.Schnorr; +using NUnit.Framework.Legacy; namespace Hydrogen.CryptoEx.Tests; @@ -60,14 +61,14 @@ public void TestThatSigningProducesSameSignatureAsTestVectors() { _vectors.Where(vec => !string.IsNullOrEmpty(vec.SecretKey)).ForEach(vec => { var schnorr = new Schnorr(ECDSAKeyType.SECP256K1); - Assert.IsTrue(schnorr.TryParsePrivateKey(vec.SecretKey.ToHexByteArray(), + ClassicAssert.IsTrue(schnorr.TryParsePrivateKey(vec.SecretKey.ToHexByteArray(), out var d), $"error creating private key index = '{vec.Index}' private key = '{vec.SecretKey}'"); var m = vec.Message.ToHexByteArray(); var a = vec.AuxRand.ToHexByteArray(); var expected = vec.Signature.ToHexByteArray(); var actual = schnorr.SignDigestWithAuxRandomData(d, m, a); - Assert.AreEqual(expected, actual, $"signature mismatch at index = '{vec.Index}'. expected = '{vec.Signature}' but got = '{actual.ToHexString()}'"); + ClassicAssert.AreEqual(expected, actual, $"signature mismatch at index = '{vec.Index}'. expected = '{vec.Signature}' but got = '{actual.ToHexString()}'"); }); } @@ -86,7 +87,7 @@ public void TestCanVerifyTestVectorsSignatures() { } catch (Exception) { actual = false; } - Assert.AreEqual(expected, actual, $"verification failure at index = '{vec.Index}'. expected = '{expected}' but got = '{actual}'"); + ClassicAssert.AreEqual(expected, actual, $"verification failure at index = '{vec.Index}'. expected = '{expected}' but got = '{actual}'"); }); } @@ -98,7 +99,7 @@ public void TestThatBatchVerifyVerifiesAllValidTestVectorsSignatures() { var signatures = positiveVectors.Select(vec => vec.Signature.ToHexByteArray()).ToArray(); var schnorr = new Schnorr(ECDSAKeyType.SECP256K1); var actual = schnorr.BatchVerifyDigest(signatures, messages, pubKeys); - Assert.AreEqual(true, actual, $"batch verification failure. expected = '{true}' but got = '{actual}'"); + ClassicAssert.AreEqual(true, actual, $"batch verification failure. expected = '{true}' but got = '{actual}'"); } [Test] @@ -122,9 +123,9 @@ public void TestThatBatchVerifyFailsOnOneInvalidSignature() { exception = e; } - Assert.AreEqual(false, actual, $"batch verification failure. expected = '{false}' but got = '{actual}'"); - Assert.IsNotNull(exception); - Assert.AreEqual("c is not equal to y^2", exception?.Message); + ClassicAssert.AreEqual(false, actual, $"batch verification failure. expected = '{false}' but got = '{actual}'"); + ClassicAssert.IsNotNull(exception); + ClassicAssert.AreEqual("c is not equal to y^2", exception?.Message); } [Test] @@ -136,7 +137,7 @@ public void TestRandomSignAndVerify(ECDSAKeyType keyType) { var pk = schnorr.DerivePublicKey(sk); var sig = schnorr.SignDigest(sk, messageDigest); var actual = schnorr.VerifyDigest(sig, messageDigest, pk); - Assert.IsTrue(actual); + ClassicAssert.IsTrue(actual); } [Test] @@ -145,7 +146,7 @@ public void IsPublicKey(ECDSAKeyType keyType) { var schnorr = new Schnorr(keyType); var privateKey = schnorr.GeneratePrivateKey(); var publicKey = schnorr.DerivePublicKey(privateKey); - Assert.IsTrue(schnorr.IsPublicKey(privateKey, publicKey.RawBytes)); + ClassicAssert.IsTrue(schnorr.IsPublicKey(privateKey, publicKey.RawBytes)); } // test parsing private and public keys @@ -155,7 +156,7 @@ public void IsPublicKey(ECDSAKeyType keyType) { [TestCase(new byte[] { 0, 0 }, ECDSAKeyType.SECP256K1)] public void VerifyThatTryParsePrivateKeyFailsEarlyForBadKeys(byte[] badRawKey, ECDSAKeyType keyType) { var schnorr = new Schnorr(keyType); - Assert.IsFalse(schnorr.TryParsePrivateKey(badRawKey, out _)); + ClassicAssert.IsFalse(schnorr.TryParsePrivateKey(badRawKey, out _)); } [Test] @@ -163,9 +164,9 @@ public void VerifyThatTryParsePrivateKeyFailsEarlyForBadKeys(byte[] badRawKey, E public void VerifyThatTryParsePrivateKeyFailsForValuesNotInBetweenZeroToCurveOrderMinusOne(ECDSAKeyType keyType) { var schnorr = new Schnorr(keyType); var negativeOne = BigInteger.One.Negate(); - Assert.IsFalse(schnorr.TryParsePrivateKey(negativeOne.ToByteArray(), out _)); + ClassicAssert.IsFalse(schnorr.TryParsePrivateKey(negativeOne.ToByteArray(), out _)); var order = keyType.GetAttribute().Value; - Assert.IsFalse(schnorr.TryParsePrivateKey(BigIntegerUtils.BigIntegerToBytes(order.Add(BigInteger.One), schnorr.KeySize), out _)); + ClassicAssert.IsFalse(schnorr.TryParsePrivateKey(BigIntegerUtils.BigIntegerToBytes(order.Add(BigInteger.One), schnorr.KeySize), out _)); } [Test] @@ -173,8 +174,8 @@ public void VerifyThatTryParsePrivateKeyFailsForValuesNotInBetweenZeroToCurveOrd public void VerifyThatTryParsePrivateKeyPassForGoodKeys(ECDSAKeyType keyType) { var schnorr = new Schnorr(keyType); var privateKeyBytes = schnorr.GeneratePrivateKey().RawBytes; - Assert.IsTrue(schnorr.TryParsePrivateKey(privateKeyBytes, out var privateKey)); - Assert.AreEqual(privateKeyBytes, privateKey.RawBytes); + ClassicAssert.IsTrue(schnorr.TryParsePrivateKey(privateKeyBytes, out var privateKey)); + ClassicAssert.AreEqual(privateKeyBytes, privateKey.RawBytes); } [Test] @@ -182,7 +183,7 @@ public void VerifyThatTryParsePrivateKeyPassForGoodKeys(ECDSAKeyType keyType) { [TestCase(new byte[] { 0, 0 }, ECDSAKeyType.SECP256K1)] public void VerifyThatTryParsePublicKeyFailsEarlyForBadKeys(byte[] badRawKey, ECDSAKeyType keyType) { var schnorr = new Schnorr(keyType); - Assert.IsFalse(schnorr.TryParsePublicKey(badRawKey, out _)); + ClassicAssert.IsFalse(schnorr.TryParsePublicKey(badRawKey, out _)); } [Test] @@ -190,9 +191,9 @@ public void VerifyThatTryParsePublicKeyFailsEarlyForBadKeys(byte[] badRawKey, EC public void VerifyThatTryParsePublicKeyFailsForValuesNotInBetweenZeroToPrimeFieldMinusOne(ECDSAKeyType keyType) { var schnorr = new Schnorr(keyType); var negativeOne = BigInteger.One.Negate(); - Assert.IsFalse(schnorr.TryParsePublicKey(negativeOne.ToByteArray(), out _)); + ClassicAssert.IsFalse(schnorr.TryParsePublicKey(negativeOne.ToByteArray(), out _)); var primeField = keyType.GetAttribute().Value; - Assert.IsFalse(schnorr.TryParsePublicKey(BigIntegerUtils.BigIntegerToBytes(primeField, schnorr.KeySize), out _)); + ClassicAssert.IsFalse(schnorr.TryParsePublicKey(BigIntegerUtils.BigIntegerToBytes(primeField, schnorr.KeySize), out _)); } [Test] @@ -201,7 +202,7 @@ public void VerifyThatTryParsePublicKeyPassForGoodKeys(ECDSAKeyType keyType) { var schnorr = new Schnorr(keyType); var privateKey = schnorr.GeneratePrivateKey(); var publicKeyBytes = schnorr.DerivePublicKey(privateKey).RawBytes; - Assert.IsTrue(schnorr.TryParsePublicKey(publicKeyBytes, out var publicKey)); - Assert.AreEqual(publicKeyBytes, publicKey.RawBytes); + ClassicAssert.IsTrue(schnorr.TryParsePublicKey(publicKeyBytes, out var publicKey)); + ClassicAssert.AreEqual(publicKeyBytes, publicKey.RawBytes); } } diff --git a/tests/Hydrogen.CryptoEx.Tests/BitcoinBase58EncodingTests.cs b/tests/Hydrogen.CryptoEx.Tests/BitcoinBase58EncodingTests.cs index 3387cc6b2..aa7e1fa6b 100644 --- a/tests/Hydrogen.CryptoEx.Tests/BitcoinBase58EncodingTests.cs +++ b/tests/Hydrogen.CryptoEx.Tests/BitcoinBase58EncodingTests.cs @@ -11,6 +11,7 @@ using System.Linq; using NUnit.Framework; using Hydrogen.CryptoEx.Bitcoin; +using NUnit.Framework.Legacy; namespace Hydrogen.CryptoEx.Tests; @@ -51,14 +52,14 @@ private static void TestEncode(Func encoder, IEnumerab foreach (var testCase in testCases) { var input = string.Equals(testCase.HexString, string.Empty, StringComparison.OrdinalIgnoreCase) ? Array.Empty() : HexEncoding.Decode(testCase.HexString).ToArray(); var result = encoder(input); - Assert.AreEqual(testCase.Base58String, result); + ClassicAssert.AreEqual(testCase.Base58String, result); } } private static void TestDecode(Func decoder, IEnumerable> testCases) { foreach (var testCase in testCases) { var result = decoder(testCase.Base58String); - Assert.AreEqual(testCase.HexString, HexEncoding.Encode(result)); + ClassicAssert.AreEqual(testCase.HexString, HexEncoding.Encode(result)); } } @@ -74,25 +75,25 @@ public void TestShouldDecodeProperly() { [Test] public void TestShouldFailOnInvalidBase58() { - Assert.IsFalse(BitcoinBase58Encoding.TryDecode("invalid", out _)); - Assert.IsFalse(BitcoinBase58Encoding.TryDecode("invalid\0", out _)); - Assert.IsFalse(BitcoinBase58Encoding.TryDecode("\0invalid", out _)); + ClassicAssert.IsFalse(BitcoinBase58Encoding.TryDecode("invalid", out _)); + ClassicAssert.IsFalse(BitcoinBase58Encoding.TryDecode("invalid\0", out _)); + ClassicAssert.IsFalse(BitcoinBase58Encoding.TryDecode("\0invalid", out _)); - Assert.IsFalse(BitcoinBase58Encoding.TryDecode("bad0IOl", out _)); - Assert.IsFalse(BitcoinBase58Encoding.TryDecode("goodbad0IOl", out _)); - Assert.IsFalse(BitcoinBase58Encoding.TryDecode("good\0bad0IOl", out _)); + ClassicAssert.IsFalse(BitcoinBase58Encoding.TryDecode("bad0IOl", out _)); + ClassicAssert.IsFalse(BitcoinBase58Encoding.TryDecode("goodbad0IOl", out _)); + ClassicAssert.IsFalse(BitcoinBase58Encoding.TryDecode("good\0bad0IOl", out _)); // check that DecodeBase58 skips whitespace, but still fails with unexpected non-whitespace at the end. - Assert.IsFalse(BitcoinBase58Encoding.TryDecode(" \t\n\v\f\r skip \r\f\v\n\t a", out _)); + ClassicAssert.IsFalse(BitcoinBase58Encoding.TryDecode(" \t\n\v\f\r skip \r\f\v\n\t a", out _)); } [Test] public void TestShouldPassOnValidBase58() { - Assert.IsTrue(BitcoinBase58Encoding.TryDecode("good", out _)); - Assert.IsTrue(BitcoinBase58Encoding.TryDecode(" ", out _)); + ClassicAssert.IsTrue(BitcoinBase58Encoding.TryDecode("good", out _)); + ClassicAssert.IsTrue(BitcoinBase58Encoding.TryDecode(" ", out _)); var result = BitcoinBase58Encoding.Decode(" \t\n\v\f\r skip \r\f\v\n\t "); var expected = HexEncoding.Decode("971a55"); - Assert.AreEqual(expected, result); + ClassicAssert.AreEqual(expected, result); } } diff --git a/tests/Hydrogen.CryptoEx.Tests/CryptoTest.cs b/tests/Hydrogen.CryptoEx.Tests/CryptoTest.cs index ed8496e2f..e32e54049 100644 --- a/tests/Hydrogen.CryptoEx.Tests/CryptoTest.cs +++ b/tests/Hydrogen.CryptoEx.Tests/CryptoTest.cs @@ -40,7 +40,7 @@ // var digest = DoSha256Digest(Encoding.UTF8.GetBytes("PascalCoin")); // var privateKey = GetNewPrivateKey(ecOpensslNid); // var sig = DoEcdsaSign(privateKey, digest); -// Assert.IsTrue(ECCrypto.ECDSAVerify(privateKey.PublicKey, digest, sig)); +// ClassicAssert.IsTrue(ECCrypto.ECDSAVerify(privateKey.PublicKey, digest, sig)); // } // [Test] @@ -53,7 +53,7 @@ // DoSha256Digest(Encoding.UTF8.GetBytes("PascalCoin"))); // var encodeSig = ECCrypto.EncodeSignature(origSig); // _ = ECCrypto.DecodeSignature(encodeSig, out var newSig); -// Assert.IsTrue(AreEcdsaSigEqual(origSig, newSig)); +// ClassicAssert.IsTrue(AreEcdsaSigEqual(origSig, newSig)); // } // [Test] @@ -67,7 +67,7 @@ // var serialized = originalPubKey.ToSerialized(); // ECDSA_Public reconstructedPubKey = default; // reconstructedPubKey.FromSerialized(serialized); -// Assert.IsTrue(originalPubKey.IsEqualTo(reconstructedPubKey)); +// ClassicAssert.IsTrue(originalPubKey.IsEqualTo(reconstructedPubKey)); // } // [Test] @@ -79,7 +79,7 @@ // var originalPrivateKey = GetNewPrivateKey(ecOpensslNid); // var raw = originalPrivateKey.ExportToRaw(); // var reconstructedPrivateKey = ECPrivateKey.ImportFromRaw(raw); -// Assert.IsTrue(AreEcPrivateKeyEqual(originalPrivateKey, reconstructedPrivateKey)); +// ClassicAssert.IsTrue(AreEcPrivateKeyEqual(originalPrivateKey, reconstructedPrivateKey)); // } // [Test] @@ -90,8 +90,8 @@ // var isDecrypted = // ECCrypto.DoPascalCoinAESDecrypt(ECCrypto.DoPascalCoinAESEncrypt(message, password), // password, ref decryptedMessage); -// Assert.IsTrue(isDecrypted); -// Assert.IsTrue(message.SequenceEqual(decryptedMessage)); +// ClassicAssert.IsTrue(isDecrypted); +// ClassicAssert.IsTrue(message.SequenceEqual(decryptedMessage)); // } // [Test] @@ -113,11 +113,11 @@ // var privateKey = GetNewPrivateKey(ecOpensslNid); // var publicKey = privateKey.PublicKey; // var isEncrypted = ECCrypto.DoPascalCoinECIESEncrypt(publicKey, message, ref encryptedMessage); -// Assert.IsTrue(isEncrypted); +// ClassicAssert.IsTrue(isEncrypted); // var isDecrypted = ECCrypto.DoPascalCoinECIESDecrypt(privateKey.EC_OpenSSL_NID, // privateKey.PrivateKey.RAW_PrivKey, encryptedMessage, ref decryptedMessage); -// Assert.IsTrue(isDecrypted); -// Assert.IsTrue(message.SequenceEqual(decryptedMessage)); +// ClassicAssert.IsTrue(isDecrypted); +// ClassicAssert.IsTrue(message.SequenceEqual(decryptedMessage)); // } // } //} diff --git a/tests/Hydrogen.CryptoEx.Tests/DigestTest.cs b/tests/Hydrogen.CryptoEx.Tests/DigestTest.cs index 667fa4009..6cf6597fd 100644 --- a/tests/Hydrogen.CryptoEx.Tests/DigestTest.cs +++ b/tests/Hydrogen.CryptoEx.Tests/DigestTest.cs @@ -7,6 +7,7 @@ // This notice must not be removed when duplicating this file or its contents, in whole or in part. using NUnit.Framework; +using NUnit.Framework.Legacy; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Utilities; using Org.BouncyCastle.Utilities.Encoders; @@ -56,7 +57,7 @@ protected virtual void PerformTest() { _digest.BlockUpdate(lastV, lastV.Length / 2, lastV.Length - lastV.Length / 2); _digest.DoFinal(resBuf, 0); - Assert.AreEqual(lastDigest, + ClassicAssert.AreEqual(lastDigest, resBuf, string.Format("fail clone vector test, expected {0} but got {1}", _results[_results.Length - 1], @@ -65,7 +66,7 @@ protected virtual void PerformTest() { d.BlockUpdate(lastV, lastV.Length / 2, lastV.Length - lastV.Length / 2); d.DoFinal(resBuf, 0); - Assert.AreEqual(lastDigest, + ClassicAssert.AreEqual(lastDigest, resBuf, string.Format("fail second clone vector test, expected {0} but got {1}", _results[_results.Length - 1], @@ -85,7 +86,7 @@ protected virtual void PerformTest() { _digest.BlockUpdate(lastV, lastV.Length / 2, lastV.Length - lastV.Length / 2); _digest.DoFinal(resBuf, 0); - Assert.AreEqual(lastDigest, + ClassicAssert.AreEqual(lastDigest, resBuf, string.Format("fail memo vector test, expected {0} but got {1}", _results[_results.Length - 1], @@ -96,7 +97,7 @@ protected virtual void PerformTest() { _digest.BlockUpdate(lastV, lastV.Length / 2, lastV.Length - lastV.Length / 2); _digest.DoFinal(resBuf, 0); - Assert.AreEqual(lastDigest, + ClassicAssert.AreEqual(lastDigest, resBuf, string.Format("fail memo reset vector test, expected {0} but got {1}", _results[_results.Length - 1], @@ -107,7 +108,7 @@ protected virtual void PerformTest() { md.BlockUpdate(lastV, lastV.Length / 2, lastV.Length - lastV.Length / 2); md.DoFinal(resBuf, 0); - Assert.AreEqual(lastDigest, + ClassicAssert.AreEqual(lastDigest, resBuf, string.Format("fail memo copy vector test, expected {0} but got {1}", _results[_results.Length - 1], @@ -134,7 +135,7 @@ private void vectorTest( aDigest.BlockUpdate(aInput, 0, aInput.Length); aDigest.DoFinal(resBuf, 0); - Assert.AreEqual(resBuf, + ClassicAssert.AreEqual(resBuf, expected, string.Format("Vector {0} failed, got {1}", count, Hex.ToHexString(resBuf))); } diff --git a/tests/Hydrogen.CryptoEx.Tests/ECDSATests.cs b/tests/Hydrogen.CryptoEx.Tests/ECDSATests.cs index 9103b01a8..ddf790d4f 100644 --- a/tests/Hydrogen.CryptoEx.Tests/ECDSATests.cs +++ b/tests/Hydrogen.CryptoEx.Tests/ECDSATests.cs @@ -14,6 +14,7 @@ using System.IO; using System.Linq; using System.Text; +using NUnit.Framework.Legacy; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Security; @@ -93,7 +94,7 @@ public void SignVerify_Basic(ECDSAKeyType keyType) { var publicKey = ecdsa.DerivePublicKey(privateKey); var message = Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"); var sig = ecdsa.Sign(privateKey, message); - Assert.IsTrue(ecdsa.Verify(sig, message, publicKey)); + ClassicAssert.IsTrue(ecdsa.Verify(sig, message, publicKey)); } [Test] @@ -106,7 +107,7 @@ public void IsPublicKey(ECDSAKeyType keyType) { var secret = new byte[] { 0, 1, 2, 3, 4 }; // deterministic secret var privateKey = ecdsa.GeneratePrivateKey(secret); var publicKey = ecdsa.DerivePublicKey(privateKey); - Assert.IsTrue(ecdsa.IsPublicKey(privateKey, publicKey.RawBytes)); + ClassicAssert.IsTrue(ecdsa.IsPublicKey(privateKey, publicKey.RawBytes)); } [Test] @@ -117,8 +118,8 @@ public void IsPublicKey(ECDSAKeyType keyType) { public void VerifyThatTryParsePrivateKeyPassForGoodKeys(ECDSAKeyType keyType) { var ecdsa = new ECDSA(keyType); var privateKeyBytes = ecdsa.GeneratePrivateKey().RawBytes; - Assert.IsTrue(ecdsa.TryParsePrivateKey(privateKeyBytes, out var privateKey)); - Assert.AreEqual(privateKeyBytes, privateKey.RawBytes); + ClassicAssert.IsTrue(ecdsa.TryParsePrivateKey(privateKeyBytes, out var privateKey)); + ClassicAssert.AreEqual(privateKeyBytes, privateKey.RawBytes); } [Test] @@ -132,7 +133,7 @@ public void VerifyThatTryParsePrivateKeyPassForGoodKeys(ECDSAKeyType keyType) { [TestCase(new byte[] { 0, 0 }, ECDSAKeyType.SECT283K1)] public void VerifyThatTryParsePrivateKeyFailsEarlyForBadKeys(byte[] badRawKey, ECDSAKeyType keyType) { var ecdsa = new ECDSA(keyType); - Assert.IsFalse(ecdsa.TryParsePrivateKey(badRawKey, out _)); + ClassicAssert.IsFalse(ecdsa.TryParsePrivateKey(badRawKey, out _)); } [Test] @@ -143,9 +144,9 @@ public void VerifyThatTryParsePrivateKeyFailsEarlyForBadKeys(byte[] badRawKey, E public void VerifyThatTryParsePrivateKeyFailsForValuesNotInBetweenZeroToCurveOrderMinusOne(ECDSAKeyType keyType) { var ecdsa = new ECDSA(keyType); var negativeOne = BigInteger.One.Negate(); - Assert.IsFalse(ecdsa.TryParsePrivateKey(negativeOne.ToByteArray(), out _)); + ClassicAssert.IsFalse(ecdsa.TryParsePrivateKey(negativeOne.ToByteArray(), out _)); var order = keyType.GetAttribute().Value; - Assert.IsFalse(ecdsa.TryParsePrivateKey(BigIntegerUtils.BigIntegerToBytes(order.Add(BigInteger.One), ecdsa.KeySize), out _)); + ClassicAssert.IsFalse(ecdsa.TryParsePrivateKey(BigIntegerUtils.BigIntegerToBytes(order.Add(BigInteger.One), ecdsa.KeySize), out _)); } [Test] @@ -157,8 +158,8 @@ public void VerifyThatTryParsePublicKeyPassForGoodKeys(ECDSAKeyType keyType) { var ecdsa = new ECDSA(keyType); var privateKey = ecdsa.GeneratePrivateKey(); var publicKeyBytes = ecdsa.DerivePublicKey(privateKey).RawBytes; - Assert.IsTrue(ecdsa.TryParsePublicKey(publicKeyBytes, out var publicKey)); - Assert.AreEqual(publicKeyBytes, publicKey.RawBytes); + ClassicAssert.IsTrue(ecdsa.TryParsePublicKey(publicKeyBytes, out var publicKey)); + ClassicAssert.AreEqual(publicKeyBytes, publicKey.RawBytes); } [Test] @@ -172,7 +173,7 @@ public void VerifyThatTryParsePublicKeyPassForGoodKeys(ECDSAKeyType keyType) { [TestCase(new byte[] { 0, 0 }, ECDSAKeyType.SECT283K1)] public void VerifyThatTryParsePublicKeyFailsEarlyForBadKeys(byte[] badRawKey, ECDSAKeyType keyType) { var ecdsa = new ECDSA(keyType); - Assert.IsFalse(ecdsa.TryParsePublicKey(badRawKey, out _)); + ClassicAssert.IsFalse(ecdsa.TryParsePublicKey(badRawKey, out _)); } //SECT283K1 excluded as it is a binary curve @@ -183,9 +184,9 @@ public void VerifyThatTryParsePublicKeyFailsEarlyForBadKeys(byte[] badRawKey, EC public void VerifyThatTryParsePublicKeyFailsForValuesNotInBetweenZeroToPrimeFieldMinusOne(ECDSAKeyType keyType) { var ecdsa = new ECDSA(keyType); var negativeOne = BigInteger.One.Negate(); - Assert.IsFalse(ecdsa.TryParsePublicKey(negativeOne.ToByteArray(), out _)); + ClassicAssert.IsFalse(ecdsa.TryParsePublicKey(negativeOne.ToByteArray(), out _)); var primeField = keyType.GetAttribute().Value; - Assert.IsFalse(ecdsa.TryParsePublicKey(BigIntegerUtils.BigIntegerToBytes(primeField, ecdsa.CompressedPublicKeySize), out _)); + ClassicAssert.IsFalse(ecdsa.TryParsePublicKey(BigIntegerUtils.BigIntegerToBytes(primeField, ecdsa.CompressedPublicKeySize), out _)); } [Test, Repeat(64)] @@ -223,15 +224,15 @@ public void TestSignatureMalleability_Low_S(ECDSAKeyType keyType) { // normal ECDSA should be able to verify both the OriginalSig and CanonicalSig ecdsaAllowMalleability.Init(false, publicKey.Parameters.Value); ecdsaAllowMalleability.BlockUpdate(messageDigest, 0, messageDigest.Length); - Assert.IsTrue(ecdsaAllowMalleability.VerifySignature(ecdsaAllowMalleabilitySig)); + ClassicAssert.IsTrue(ecdsaAllowMalleability.VerifySignature(ecdsaAllowMalleabilitySig)); ecdsaAllowMalleability.Init(false, publicKey.Parameters.Value); ecdsaAllowMalleability.BlockUpdate(messageDigest, 0, messageDigest.Length); - Assert.IsTrue(ecdsaAllowMalleability.VerifySignature(canonicalSig)); + ClassicAssert.IsTrue(ecdsaAllowMalleability.VerifySignature(canonicalSig)); // our LowS ECDSA should be able to verify only the CanonicalSig - Assert.IsFalse(ecdsaNoMalleability.VerifyDigest(ecdsaAllowMalleabilitySig, messageDigest, publicKey)); - Assert.IsTrue(ecdsaNoMalleability.VerifyDigest(canonicalSig, messageDigest, publicKey)); + ClassicAssert.IsFalse(ecdsaNoMalleability.VerifyDigest(ecdsaAllowMalleabilitySig, messageDigest, publicKey)); + ClassicAssert.IsTrue(ecdsaNoMalleability.VerifyDigest(canonicalSig, messageDigest, publicKey)); } [Test] @@ -245,13 +246,13 @@ public void TestSignatureMalleability_Low_S(ECDSAKeyType keyType) { [TestCase("302402107777777777777777777777777777777702108777777777777777777777777777777701")] public void TestSignatureMalleability_Invalid_Strict_DER(string badDerSig) { var invalidBip66Der = badDerSig.ToHexByteArray(); - Assert.False(CustomDsaEncoding.IsValidSignatureEncoding(invalidBip66Der)); + ClassicAssert.IsFalse(CustomDsaEncoding.IsValidSignatureEncoding(invalidBip66Der)); } [Test] [TestCase("302502107777777777777777777777777777777702110087777777777777777777777777777777")] public void TestSignatureMalleability_Valid_Strict_DER(string goodDerSig) { var validBip66Der = goodDerSig.ToHexByteArray(); - Assert.True(CustomDsaEncoding.IsValidSignatureEncoding(validBip66Der)); + ClassicAssert.IsTrue(CustomDsaEncoding.IsValidSignatureEncoding(validBip66Der)); } } diff --git a/tests/Hydrogen.CryptoEx.Tests/ECIESTests.cs b/tests/Hydrogen.CryptoEx.Tests/ECIESTests.cs index 3ed1b3195..74aa7b12f 100644 --- a/tests/Hydrogen.CryptoEx.Tests/ECIESTests.cs +++ b/tests/Hydrogen.CryptoEx.Tests/ECIESTests.cs @@ -11,6 +11,7 @@ using Hydrogen.CryptoEx.EC; using System.Linq; using System.Text; +using NUnit.Framework.Legacy; using Tools; namespace Hydrogen.CryptoEx.Tests; @@ -38,8 +39,8 @@ public void EncryptDecrypt_Basic(ECDSAKeyType keyType) { var publicKey = ecdsa.DerivePublicKey(privateKey); var message = Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"); var encryptedData = ecdsa.IES.Encrypt(message, publicKey); - Assert.IsTrue(ecdsa.IES.TryDecrypt(encryptedData, out var decryptedData, privateKey)); - Assert.IsTrue(message.SequenceEqual(decryptedData.ToArray())); + ClassicAssert.IsTrue(ecdsa.IES.TryDecrypt(encryptedData, out var decryptedData, privateKey)); + ClassicAssert.IsTrue(message.SequenceEqual(decryptedData.ToArray())); } [Test] @@ -55,8 +56,8 @@ public void EncryptDecrypt_Random(ECDSAKeyType keyType, int iterations) { var publicKey = ecdsa.DerivePublicKey(privateKey); var message = Encoding.ASCII.GetBytes(RandomString(rng.Next(1, 1000), iterations)); var encryptedData = ecdsa.IES.Encrypt(message, publicKey); - Assert.IsTrue(ecdsa.IES.TryDecrypt(encryptedData, out var decryptedData, privateKey)); - Assert.IsTrue(message.SequenceEqual(decryptedData.ToArray())); + ClassicAssert.IsTrue(ecdsa.IES.TryDecrypt(encryptedData, out var decryptedData, privateKey)); + ClassicAssert.IsTrue(message.SequenceEqual(decryptedData.ToArray())); } } diff --git a/tests/Hydrogen.CryptoEx.Tests/HashTestBase.cs b/tests/Hydrogen.CryptoEx.Tests/HashTestBase.cs index c2b43457a..15a733150 100644 --- a/tests/Hydrogen.CryptoEx.Tests/HashTestBase.cs +++ b/tests/Hydrogen.CryptoEx.Tests/HashTestBase.cs @@ -10,14 +10,11 @@ using System.Collections.Generic; using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.CryptoEx.Tests; public abstract class HashTestBase { - static HashTestBase() { - HydrogenFrameworkIntegration.Initialize(); - } - protected struct TestItem { public TInput Input; @@ -29,7 +26,7 @@ protected static void TestHash(Func hasher, IEnumerabl foreach (var testCase in testCases) { var input = HexEncoding.Decode(DATA_BYTES).Take(testCase.Input).ToArray(); var result = hasher(input); - Assert.AreEqual(testCase.Expected, result); + ClassicAssert.AreEqual(testCase.Expected, result); } } diff --git a/tests/Hydrogen.CryptoEx.Tests/MuSigBuilderTest.cs b/tests/Hydrogen.CryptoEx.Tests/MuSigBuilderTest.cs index 05d33f71d..621311a40 100644 --- a/tests/Hydrogen.CryptoEx.Tests/MuSigBuilderTest.cs +++ b/tests/Hydrogen.CryptoEx.Tests/MuSigBuilderTest.cs @@ -13,6 +13,7 @@ using NUnit.Framework; using Org.BouncyCastle.Utilities; using Hydrogen.CryptoEx.EC.Schnorr; +using NUnit.Framework.Legacy; namespace Hydrogen.CryptoEx.Tests; @@ -88,7 +89,7 @@ public void TestSortPublicKeysInLexicographicOrder() { new byte[] { 255 }, }; MuSigBuilder.SortPublicKeysInLexicographicOrder(input); - CollectionAssert.AreEqual(expected, input); + ClassicAssert.AreEqual(expected, input); } [Test] @@ -151,11 +152,11 @@ public void TestFullMuSigBuilderWithKnownTestVectors() { Assert.DoesNotThrow(bobMuSigBuilder.VerifyPartialSignatures); Assert.DoesNotThrow(charlieMuSigBuilder.VerifyPartialSignatures); - Assert.AreEqual(aliceAggregatedSignature.AggregatedSignature, bobAggregatedSignature.AggregatedSignature); - Assert.AreEqual(bobAggregatedSignature.AggregatedSignature, charlieAggregatedSignature.AggregatedSignature); - Assert.AreEqual(aliceAggregatedSignature.AggregatedSignature, AggregatedSig); + ClassicAssert.AreEqual(aliceAggregatedSignature.AggregatedSignature, bobAggregatedSignature.AggregatedSignature); + ClassicAssert.AreEqual(bobAggregatedSignature.AggregatedSignature, charlieAggregatedSignature.AggregatedSignature); + ClassicAssert.AreEqual(aliceAggregatedSignature.AggregatedSignature, AggregatedSig); // since all aggregated signatures are same from above check, we can just verify one. - Assert.IsTrue(MuSig.Schnorr.VerifyDigest(charlieAggregatedSignature.AggregatedSignature, + ClassicAssert.IsTrue(MuSig.Schnorr.VerifyDigest(charlieAggregatedSignature.AggregatedSignature, MessageDigest, charlieAggregatedSignature.AggregatedPublicKey)); } @@ -217,25 +218,25 @@ public void TestFullMuSigBuilderWithKnownTestVectorsWhereAParticipantIsDishonest var errorMessage = $"partial signature verification of participant (publicKey: {bobMuSigBuilder.PublicKey.ToHexString()}) failed"; var result = Assert.Throws(() => aliceMuSigBuilder.VerifyPartialSignatures()); - Assert.AreEqual(result?.Message, errorMessage); + ClassicAssert.AreEqual(result?.Message, errorMessage); result = Assert.Throws(() => bobMuSigBuilder.VerifyPartialSignatures()); - Assert.AreEqual(result?.Message, errorMessage); + ClassicAssert.AreEqual(result?.Message, errorMessage); result = Assert.Throws(() => charlieMuSigBuilder.VerifyPartialSignatures()); - Assert.AreEqual(result?.Message, errorMessage); + ClassicAssert.AreEqual(result?.Message, errorMessage); var aliceAggregatedSignature = aliceMuSigBuilder.BuildAggregatedSignature(); var bobAggregatedSignature = bobMuSigBuilder.BuildAggregatedSignature(); var charlieAggregatedSignature = charlieMuSigBuilder.BuildAggregatedSignature(); - Assert.IsFalse(MuSig.Schnorr.VerifyDigest(aliceAggregatedSignature.AggregatedSignature, + ClassicAssert.IsFalse(MuSig.Schnorr.VerifyDigest(aliceAggregatedSignature.AggregatedSignature, MessageDigest, aliceAggregatedSignature.AggregatedPublicKey)); - Assert.IsFalse(MuSig.Schnorr.VerifyDigest(bobAggregatedSignature.AggregatedSignature, + ClassicAssert.IsFalse(MuSig.Schnorr.VerifyDigest(bobAggregatedSignature.AggregatedSignature, MessageDigest, bobAggregatedSignature.AggregatedPublicKey)); - Assert.IsFalse(MuSig.Schnorr.VerifyDigest(charlieAggregatedSignature.AggregatedSignature, + ClassicAssert.IsFalse(MuSig.Schnorr.VerifyDigest(charlieAggregatedSignature.AggregatedSignature, MessageDigest, charlieAggregatedSignature.AggregatedPublicKey)); } @@ -286,11 +287,11 @@ public void TestFullMuSigBuilderWithRandomInputs(ECDSAKeyType keyType) { aggregatedSignatures.Add(muSigBuilders[i].BuildAggregatedSignature()); } - Assert.IsTrue(aggregatedSignatures.All(bytes => bytes.AggregatedSignature.SequenceEqual(aggregatedSignatures + ClassicAssert.IsTrue(aggregatedSignatures.All(bytes => bytes.AggregatedSignature.SequenceEqual(aggregatedSignatures .First() .AggregatedSignature))); // since all aggregated signatures are same from above check, we can just verify one. - Assert.IsTrue(muSig.Schnorr.VerifyDigest(aggregatedSignatures.Last().AggregatedSignature, + ClassicAssert.IsTrue(muSig.Schnorr.VerifyDigest(aggregatedSignatures.Last().AggregatedSignature, messageDigest, aggregatedSignatures.Last().AggregatedPublicKey)); } @@ -342,7 +343,7 @@ public void TestFullMuSigBuilderWithRandomInputsWhereAParticipantIsDishonest(ECD for (var i = 0; i < numberOfSigners; i++) { // all participants validate each other partial signatures. var result = Assert.Throws(() => muSigBuilders[i].VerifyPartialSignatures()); - Assert.AreEqual(result?.Message, errorMessage); + ClassicAssert.AreEqual(result?.Message, errorMessage); } var aggregatedSignatures = new List(); @@ -351,7 +352,7 @@ public void TestFullMuSigBuilderWithRandomInputsWhereAParticipantIsDishonest(ECD } for (var i = 0; i < numberOfSigners; i++) { - Assert.IsFalse(MuSig.Schnorr.VerifyDigest(aggregatedSignatures[i].AggregatedSignature, + ClassicAssert.IsFalse(MuSig.Schnorr.VerifyDigest(aggregatedSignatures[i].AggregatedSignature, MessageDigest, aggregatedSignatures[i].AggregatedPublicKey)); } diff --git a/tests/Hydrogen.CryptoEx.Tests/MuSigTest.cs b/tests/Hydrogen.CryptoEx.Tests/MuSigTest.cs index 52ef23fbb..6ccb69c11 100644 --- a/tests/Hydrogen.CryptoEx.Tests/MuSigTest.cs +++ b/tests/Hydrogen.CryptoEx.Tests/MuSigTest.cs @@ -14,6 +14,7 @@ using Org.BouncyCastle.Math; using Org.BouncyCastle.Utilities; using Hydrogen.CryptoEx.EC.Schnorr; +using NUnit.Framework.Legacy; namespace Hydrogen.CryptoEx.Tests; @@ -33,7 +34,7 @@ private static Schnorr.PrivateKey[] GetPrivateKeys(MuSig muSig, byte[][] keys) { var privateKeys = new Schnorr.PrivateKey[keys.Length]; var i = 0; foreach (var key in keys) { - Assert.True(muSig.Schnorr.TryParsePrivateKey(key, out var privateKey)); + ClassicAssert.IsTrue(muSig.Schnorr.TryParsePrivateKey(key, out var privateKey)); privateKeys[i++] = privateKey; } return privateKeys; @@ -98,7 +99,7 @@ public void TestFullMuSigWithTestVectors() { // 2. compute the public keys hash. var publicKeyHash = muSig.ComputeEll(publicKeys); - Assert.AreEqual(publicKeyHashVector, publicKeyHash.ToHexString(true)); + ClassicAssert.AreEqual(publicKeyHashVector, publicKeyHash.ToHexString(true)); // 3. get second public key var secondPublicKey = muSig.GetSecondPublicKey(publicKeys); @@ -121,7 +122,7 @@ public void TestFullMuSigWithTestVectors() { var publicKeyAggregationData = muSig.AggregatePublicKeys(keyCoefficients, publicKeys); var combinedPublicKey = muSig.Schnorr.BytesOfXCoord(publicKeyAggregationData.CombinedPoint); - Assert.AreEqual(combinedPublicKeyVector, combinedPublicKey.ToHexString(true)); + ClassicAssert.AreEqual(combinedPublicKeyVector, combinedPublicKey.ToHexString(true)); var publicKeyParity = publicKeyAggregationData.PublicKeyParity; @@ -131,19 +132,19 @@ public void TestFullMuSigWithTestVectors() { // 6. combine nonce var publicNonces = signerSessions.Select(x => x.PublicNonce).ToArray(); - Assert.AreEqual(noncesVector.Select(x => x.ToHexByteArray()).ToArray(), publicNonces); + ClassicAssert.AreEqual(noncesVector.Select(x => x.ToHexByteArray()).ToArray(), publicNonces); /* Create aggregate nonce */ var combinedNonce = muSig.AggregatePublicNonces(publicNonces, combinedPublicKey, messageDigest); - Assert.AreEqual(combinedNonceVector, combinedNonce.AggregatedNonce.ToHexString(true)); + ClassicAssert.AreEqual(combinedNonceVector, combinedNonce.AggregatedNonce.ToHexString(true)); // 7. compute challenge var challenge = muSig.ComputeChallenge(combinedNonce.FinalNonce, combinedPublicKey, messageDigest); // 8. initialize musig session cache. same for all signers var sessionCache = muSig.InitializeSessionCache(combinedNonce, challenge, publicKeyParity); - Assert.AreEqual(sessionCacheVector, GetSessionCacheAsBytes(sessionCache).ToHexString(true)); + ClassicAssert.AreEqual(sessionCacheVector, GetSessionCacheAsBytes(sessionCache).ToHexString(true)); // 9. generate partial signatures var partialSignatures = new BigInteger[numberOfSigners]; @@ -151,7 +152,7 @@ public void TestFullMuSigWithTestVectors() { partialSignatures[i] = muSig.PartialSign(signerSessions[i], sessionCache); } - Assert.AreEqual(sigsVector.Select(x => x.ToHexByteArray()), + ClassicAssert.AreEqual(sigsVector.Select(x => x.ToHexByteArray()), partialSignatures.Select(x => BigIntegerUtils.BigIntegerToBytes(x, 32)) .ToArray()); @@ -161,15 +162,15 @@ public void TestFullMuSigWithTestVectors() { // 10. verify individual partial signatures for (var i = 0; i < numberOfSigners; i++) { - Assert.IsTrue(muSig.PartialSigVerify(signerSessions[i], sessionCache, publicKeys[i], partialSignatures[i])); + ClassicAssert.IsTrue(muSig.PartialSigVerify(signerSessions[i], sessionCache, publicKeys[i], partialSignatures[i])); } // 11. combine partial signatures var combinedSignature = muSig.AggregatePartialSignatures(sessionCache.FinalNonce, partialSignatures); - Assert.AreEqual(combinedSigsVector, combinedSignature.ToHexString(true)); + ClassicAssert.AreEqual(combinedSigsVector, combinedSignature.ToHexString(true)); // 12. validate combined signature - Assert.IsTrue(muSig.Schnorr.VerifyDigest(combinedSignature, messageDigest, combinedPublicKey)); + ClassicAssert.IsTrue(muSig.Schnorr.VerifyDigest(combinedSignature, messageDigest, combinedPublicKey)); } [Test] @@ -240,14 +241,14 @@ public void TestFullMuSigWithRandomSignAndVerify(ECDSAKeyType keyType) { // 10. verify individual partial signatures for (var i = 0; i < numberOfSigners; i++) { - Assert.IsTrue(muSig.PartialSigVerify(signerSessions[i], sessionCache, publicKeys[i], partialSignatures[i])); + ClassicAssert.IsTrue(muSig.PartialSigVerify(signerSessions[i], sessionCache, publicKeys[i], partialSignatures[i])); } // 11. combine partial signatures var combinedSignature = muSig.AggregatePartialSignatures(sessionCache.FinalNonce, partialSignatures); // 11. validate combined signature - Assert.IsTrue(muSig.Schnorr.VerifyDigest(combinedSignature, messageDigest, combinedPublicKey)); + ClassicAssert.IsTrue(muSig.Schnorr.VerifyDigest(combinedSignature, messageDigest, combinedPublicKey)); } } diff --git a/tests/Hydrogen.CryptoEx.Tests/Murmur3_x86_32DigestTest.cs b/tests/Hydrogen.CryptoEx.Tests/Murmur3_x86_32DigestTest.cs index c77923560..bdea4056a 100644 --- a/tests/Hydrogen.CryptoEx.Tests/Murmur3_x86_32DigestTest.cs +++ b/tests/Hydrogen.CryptoEx.Tests/Murmur3_x86_32DigestTest.cs @@ -10,6 +10,7 @@ using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Utilities.Encoders; using Hydrogen.CryptoEx.HF; +using NUnit.Framework.Legacy; namespace NPascalCoin.UnitTests.Crypto; @@ -55,7 +56,7 @@ private void PerformUInt32VectorTest(string testTitle, byte[] inputBytes, private void DoPerformTest(string testTitle, byte[] inputBytes, uint resultsAsUInt32) { uint resUInt32 = CreateUInt32OutputFromDigest(inputBytes); - Assert.AreEqual(resultsAsUInt32, resUInt32, testTitle); + ClassicAssert.AreEqual(resultsAsUInt32, resUInt32, testTitle); } private uint CreateUInt32OutputFromDigest(byte[] digestBytes) { diff --git a/tests/Hydrogen.CryptoEx.Tests/OpenSSLConsistencyTests.cs b/tests/Hydrogen.CryptoEx.Tests/OpenSSLConsistencyTests.cs index dd32f45ed..630920ba8 100644 --- a/tests/Hydrogen.CryptoEx.Tests/OpenSSLConsistencyTests.cs +++ b/tests/Hydrogen.CryptoEx.Tests/OpenSSLConsistencyTests.cs @@ -15,6 +15,7 @@ using System.Text; using Tools; using System.IO; +using NUnit.Framework.Legacy; namespace Hydrogen.CryptoEx.Tests; @@ -94,7 +95,7 @@ public void TestThatWeCanVerifyOpenSSLSignatures([Values] ECDSAKeyType keyType, var sig = CallPascalOpenSSL(args).ToHexByteArray(); // OpenSSL doesn't take into account the "LowS fix" to resolve signature malleability so we account for it here sig = ECDSATests.CanonicalizeSig(order, sig); - Assert.IsTrue(ecdsa.VerifyDigest(sig, messageDigest.ToHexByteArray(), publicKey)); + ClassicAssert.IsTrue(ecdsa.VerifyDigest(sig, messageDigest.ToHexByteArray(), publicKey)); } [Test] @@ -121,7 +122,7 @@ public void TestThatOpenSSLCanVerifyOurSignatures([Values] ECDSAKeyType keyType, }; var isValidSig = CallPascalOpenSSL(args); - Assert.IsTrue(isValidSig.ToBool()); + ClassicAssert.IsTrue(isValidSig.ToBool()); } @@ -156,6 +157,6 @@ public void TestThatOpenSSLDoesNotVerifyBadSignatures([Values] ECDSAKeyType keyT }; var isValidSig = CallPascalOpenSSL(args); - Assert.IsFalse(isValidSig.ToBool()); + ClassicAssert.IsFalse(isValidSig.ToBool()); } } diff --git a/tests/Hydrogen.CryptoEx.Tests/Pascal64EncodingTests.cs b/tests/Hydrogen.CryptoEx.Tests/Pascal64EncodingTests.cs index b0af1f0d1..0ec37a4b9 100644 --- a/tests/Hydrogen.CryptoEx.Tests/Pascal64EncodingTests.cs +++ b/tests/Hydrogen.CryptoEx.Tests/Pascal64EncodingTests.cs @@ -10,6 +10,7 @@ using Hydrogen.CryptoEx.PascalCoin; using Hydrogen.NUnit; using System.Linq; +using NUnit.Framework.Legacy; namespace Hydrogen.CryptoEx; @@ -156,20 +157,20 @@ public void Pascal64StringPattern_Long() { public void Encoding_EscapeString() { var escaped = @"\(a\)b\{c\}d\[e\]f\:g\""h\"; var unescaped = @"(a)b{c}d[e]f:g""h"; - Assert.AreEqual(escaped, Pascal64Encoding.Escape(unescaped)); - Assert.AreEqual(escaped, Pascal64Encoding.Escape(Pascal64Encoding.Escape(unescaped))); - Assert.IsFalse(Pascal64Encoding.IsValidEscaped(unescaped)); - Assert.IsTrue(Pascal64Encoding.IsValidEscaped(escaped)); + ClassicAssert.AreEqual(escaped, Pascal64Encoding.Escape(unescaped)); + ClassicAssert.AreEqual(escaped, Pascal64Encoding.Escape(Pascal64Encoding.Escape(unescaped))); + ClassicAssert.IsFalse(Pascal64Encoding.IsValidEscaped(unescaped)); + ClassicAssert.IsTrue(Pascal64Encoding.IsValidEscaped(escaped)); } [Test] public void Encoding_UnescapedString() { var escaped = @"\(a\)b\{c\}d\[e\]f\:g\""h\"; var unescaped = @"(a)b{c}d[e]f:g""h"; - Assert.AreEqual(unescaped, Pascal64Encoding.Unescape(escaped)); - Assert.AreEqual(unescaped, Pascal64Encoding.Unescape(Pascal64Encoding.Unescape(escaped))); - Assert.IsFalse(Pascal64Encoding.IsValidUnescaped(escaped)); - Assert.IsTrue(Pascal64Encoding.IsValidUnescaped(unescaped)); + ClassicAssert.AreEqual(unescaped, Pascal64Encoding.Unescape(escaped)); + ClassicAssert.AreEqual(unescaped, Pascal64Encoding.Unescape(Pascal64Encoding.Unescape(escaped))); + ClassicAssert.IsFalse(Pascal64Encoding.IsValidUnescaped(escaped)); + ClassicAssert.IsTrue(Pascal64Encoding.IsValidUnescaped(unescaped)); } #endregion diff --git a/tests/Hydrogen.CryptoEx.Tests/PascalAsciiEncodingTests.cs b/tests/Hydrogen.CryptoEx.Tests/PascalAsciiEncodingTests.cs index 297013cc6..a3b7dffa6 100644 --- a/tests/Hydrogen.CryptoEx.Tests/PascalAsciiEncodingTests.cs +++ b/tests/Hydrogen.CryptoEx.Tests/PascalAsciiEncodingTests.cs @@ -10,6 +10,7 @@ using Hydrogen.CryptoEx.PascalCoin; using Hydrogen.NUnit; using System.Linq; +using NUnit.Framework.Legacy; namespace Hydrogen.CryptoEx; @@ -108,20 +109,20 @@ public void PascalAsciiStringPattern_IllegalCharSet() { public void Encoding_EscapeString() { var unescaped = @"""a(b)c:df[g\h]i{j}"; var escaped = @"\""a\(b\)c\:d\f\[g\\h\]i\{j\}"; - Assert.AreEqual(escaped, PascalAsciiEncoding.Escape(unescaped)); - Assert.AreEqual(escaped, PascalAsciiEncoding.Escape(PascalAsciiEncoding.Escape(unescaped))); - Assert.IsTrue(PascalAsciiEncoding.IsValidEscaped(escaped)); - Assert.IsTrue(PascalAsciiEncoding.IsValidEscaped(unescaped)); // unescaped is also a valid escaped string (unlike pascal64 encoding) + ClassicAssert.AreEqual(escaped, PascalAsciiEncoding.Escape(unescaped)); + ClassicAssert.AreEqual(escaped, PascalAsciiEncoding.Escape(PascalAsciiEncoding.Escape(unescaped))); + ClassicAssert.IsTrue(PascalAsciiEncoding.IsValidEscaped(escaped)); + ClassicAssert.IsTrue(PascalAsciiEncoding.IsValidEscaped(unescaped)); // unescaped is also a valid escaped string (unlike pascal64 encoding) } [Test] public void Encoding_UnescapedString() { var unescaped = @"""a(b)c:df[g\h]i{j}"; var escaped = @"\""a\(b\)c\:d\f\[g\\h\]i\{j\}"; - Assert.AreEqual(unescaped, PascalAsciiEncoding.Unescape(escaped)); - Assert.AreEqual(unescaped, PascalAsciiEncoding.Unescape(PascalAsciiEncoding.Unescape(escaped))); - Assert.IsTrue(PascalAsciiEncoding.IsValidUnescaped(escaped)); // escaped string is also valid as unescaped, since \ is allowed - Assert.IsTrue(PascalAsciiEncoding.IsValidUnescaped(unescaped)); + ClassicAssert.AreEqual(unescaped, PascalAsciiEncoding.Unescape(escaped)); + ClassicAssert.AreEqual(unescaped, PascalAsciiEncoding.Unescape(PascalAsciiEncoding.Unescape(escaped))); + ClassicAssert.IsTrue(PascalAsciiEncoding.IsValidUnescaped(escaped)); // escaped string is also valid as unescaped, since \ is allowed + ClassicAssert.IsTrue(PascalAsciiEncoding.IsValidUnescaped(unescaped)); } #endregion diff --git a/tests/Hydrogen.CryptoEx.Tests/PascalBase58EncodingTests.cs b/tests/Hydrogen.CryptoEx.Tests/PascalBase58EncodingTests.cs index 05eeb94ae..b578e62ea 100644 --- a/tests/Hydrogen.CryptoEx.Tests/PascalBase58EncodingTests.cs +++ b/tests/Hydrogen.CryptoEx.Tests/PascalBase58EncodingTests.cs @@ -21,8 +21,8 @@ // // Test values derived from Pascal implementation // const string keyBase58 = "3GhhbonKEE3SzPvRqPEeXbLc1v1LCcYvqY7wuxW8esJLCb2FCj4jofWmkmMTtqP1atrmioAMqEwigHA2CEwidxgB1i1gGhL39unBkk"; // const string keyHex = "ca0220003ce142a2bfa1e2d4c6246bf7dfa8106d975f498133fb7084e83062f8941d09ea2000ab8fa84d3287d8efe04b865e50f9c7ff2a9a85187191c2528045e697ec9d8b5143db2899"; -// Assert.AreEqual(keyBase58, PascalBase58Encoding.Encode(keyHex.ToHexByteArray())); -// Assert.AreEqual(keyHex, PascalBase58Encoding.Decode(keyBase58).ToHexString(true)); +// ClassicAssert.AreEqual(keyBase58, PascalBase58Encoding.Encode(keyHex.ToHexByteArray())); +// ClassicAssert.AreEqual(keyHex, PascalBase58Encoding.Decode(keyBase58).ToHexString(true)); // } // // } diff --git a/tests/Hydrogen.CryptoEx.Tests/PascalCoinEciesTest.cs b/tests/Hydrogen.CryptoEx.Tests/PascalCoinEciesTest.cs index 1fbe5eba0..17266b7d3 100644 --- a/tests/Hydrogen.CryptoEx.Tests/PascalCoinEciesTest.cs +++ b/tests/Hydrogen.CryptoEx.Tests/PascalCoinEciesTest.cs @@ -152,7 +152,7 @@ // string decryptedPayload = DoPascalCoinEciesDecrypt(keyType, rawPrivateKey, // payloadToDecrypt); // -// Assert.AreEqual(expectedOutput, decryptedPayload, string.Format("Test {0} Failed, Expected {1} but got {2}", +// ClassicAssert.AreEqual(expectedOutput, decryptedPayload, string.Format("Test {0} Failed, Expected {1} but got {2}", // id + "_Decrypt", expectedOutput, // decryptedPayload)); // } @@ -165,7 +165,7 @@ // DoPascalCoinEciesEncrypt(keyType, rawAffineXCoord, rawAffineYCoord, // payloadToEncrypt)); // -// Assert.AreEqual(payloadToEncrypt, actualOutput, string.Format("Test {0} Failed, Expected {1} but got {2}", +// ClassicAssert.AreEqual(payloadToEncrypt, actualOutput, string.Format("Test {0} Failed, Expected {1} but got {2}", // id + "_EncryptDecrypt", // payloadToEncrypt, // actualOutput)); diff --git a/tests/Hydrogen.CryptoEx.Tests/RegisterCryptoExModule.cs b/tests/Hydrogen.CryptoEx.Tests/RegisterCryptoExModule.cs index 213f26915..820152222 100644 --- a/tests/Hydrogen.CryptoEx.Tests/RegisterCryptoExModule.cs +++ b/tests/Hydrogen.CryptoEx.Tests/RegisterCryptoExModule.cs @@ -12,14 +12,14 @@ namespace Hydrogen.CryptoEx.Tests; [SetUpFixture] public class RegisterCryptoExModule { - + [OneTimeSetUp] public void RegisterModule() { - HydrogenFrameworkIntegration.Initialize(); + Hydrogen.CryptoEx.ModuleConfiguration.InitializeInternal(); } [OneTimeTearDown] public void DeregisterModule() { - HydrogenFrameworkIntegration.Finalize(); + Hydrogen.CryptoEx.ModuleConfiguration.FinalizeInternal(); } } diff --git a/tests/Hydrogen.DApp.Core.Tests/HexEncodingTests.cs b/tests/Hydrogen.DApp.Core.Tests/HexEncodingTests.cs index ded545a3f..e8449fe07 100644 --- a/tests/Hydrogen.DApp.Core.Tests/HexEncodingTests.cs +++ b/tests/Hydrogen.DApp.Core.Tests/HexEncodingTests.cs @@ -9,6 +9,7 @@ using System; using NUnit.Framework; using Hydrogen; +using NUnit.Framework.Legacy; namespace VelocityNET.Processing.Tests.Core; @@ -16,24 +17,24 @@ public class HexEncodingTests { [Test] public void Simple() { - Assert.AreEqual(new[] { 1, 2, 3 }, HexEncoding.Decode("0x010203")); - Assert.AreEqual(new[] { 1, 2, 3 }, HexEncoding.Decode("010203")); + ClassicAssert.AreEqual(new[] { 1, 2, 3 }, HexEncoding.Decode("0x010203")); + ClassicAssert.AreEqual(new[] { 1, 2, 3 }, HexEncoding.Decode("010203")); Assert.Throws(() => HexEncoding.ByteLength("0x1")); Assert.Throws(() => HexEncoding.ByteLength("0x012")); } [Test] public void IsValid() { - Assert.IsTrue(HexEncoding.IsValid("0x0")); - Assert.IsFalse(HexEncoding.IsValid("0x")); - Assert.IsTrue(HexEncoding.IsValid("00")); - Assert.IsFalse(HexEncoding.IsValid("0")); // should be double-digits + ClassicAssert.IsTrue(HexEncoding.IsValid("0x0")); + ClassicAssert.IsFalse(HexEncoding.IsValid("0x")); + ClassicAssert.IsTrue(HexEncoding.IsValid("00")); + ClassicAssert.IsFalse(HexEncoding.IsValid("0")); // should be double-digits } [Test] public void ByteLength() { - Assert.AreEqual(0, HexEncoding.ByteLength("0x0")); - Assert.AreEqual(1, HexEncoding.ByteLength("0x00")); + ClassicAssert.AreEqual(0, HexEncoding.ByteLength("0x0")); + ClassicAssert.AreEqual(1, HexEncoding.ByteLength("0x00")); Assert.Throws(() => HexEncoding.ByteLength("0x000")); } diff --git a/tests/Hydrogen.DApp.Core.Tests/RandomHash2Test.cs b/tests/Hydrogen.DApp.Core.Tests/RandomHash2Test.cs index 46678fe5a..a51b3c25a 100644 --- a/tests/Hydrogen.DApp.Core.Tests/RandomHash2Test.cs +++ b/tests/Hydrogen.DApp.Core.Tests/RandomHash2Test.cs @@ -11,6 +11,7 @@ using Hydrogen.DApp.Core.Maths; using System; using System.Text; +using NUnit.Framework.Legacy; namespace Hydrogen.DApp.Core.Tests; @@ -82,15 +83,12 @@ protected struct TestItem { #endregion - protected static void AssertAreEqual(byte[] expected, byte[] actual) => Assert.AreEqual(expected, actual); + protected static void AssertAreEqual(byte[] expected, byte[] actual) => ClassicAssert.AreEqual(expected, actual); // if stars with 0x parses as input hexstring else ascii protected static byte[] ParseBytes(string input) => input.StartsWith("0x") ? HexEncoding.Decode(input) : Encoding.ASCII.GetBytes(input); - static RandomHash2TestBase() { - HydrogenFrameworkIntegration.Initialize(); - } } @@ -122,7 +120,7 @@ public void TestGetSetLastDWordConsistency() { var hasher = RandomHash2.RandomHash2Instance(); for (var idx = 1; idx <= 100; idx++) { var buffer2 = hasher.Hash(buffer); - Assert.AreEqual(32768 + idx, + ClassicAssert.AreEqual(32768 + idx, RandomHashUtils.GetLastDWordLE(RandomHashUtils.SetLastDWordLE(buffer2, (uint)(32768 + idx)))); } } diff --git a/tests/Hydrogen.DApp.Core.Tests/TargetTests.cs b/tests/Hydrogen.DApp.Core.Tests/TargetTests.cs index 9917ccb0a..1c04aa749 100644 --- a/tests/Hydrogen.DApp.Core.Tests/TargetTests.cs +++ b/tests/Hydrogen.DApp.Core.Tests/TargetTests.cs @@ -9,6 +9,7 @@ using NUnit.Framework; using Hydrogen; using Hydrogen.DApp.Core.Maths; +using NUnit.Framework.Legacy; namespace VelocityNET.Processing.Tests.Core; @@ -21,7 +22,7 @@ public void Basic() { var expected = targetAlg.MinCompactTarget; var target = targetAlg.ToDigest(expected); var actual = targetAlg.FromDigest(target); - Assert.AreEqual(expected, actual); + ClassicAssert.AreEqual(expected, actual); } [Test] @@ -32,8 +33,8 @@ void Check(string hexBytes, string expectedTarget, uint expectedCompactTarget) { var bytes = HexEncoding.Decode(new string(hexBytes)); var compact = targetAlg.FromDigest(bytes); var target = targetAlg.ToDigest(compact); - Assert.AreEqual(HexEncoding.Decode(expectedTarget), target); - Assert.AreEqual(expectedCompactTarget, compact); + ClassicAssert.AreEqual(HexEncoding.Decode(expectedTarget), target); + ClassicAssert.AreEqual(expectedCompactTarget, compact); } diff --git a/tests/Hydrogen.DApp.Core.Tests/UInt256Test.cs b/tests/Hydrogen.DApp.Core.Tests/UInt256Test.cs index 975a9e71f..5f9c3d255 100644 --- a/tests/Hydrogen.DApp.Core.Tests/UInt256Test.cs +++ b/tests/Hydrogen.DApp.Core.Tests/UInt256Test.cs @@ -27,40 +27,40 @@ // var vless = new UInt256("00000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffe"); // var vplus = new UInt256("00000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); -// Assert.True(HexEncoding.IsValid("0xff")); - -// Assert.AreEqual("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", v.ToString()); -// Assert.AreEqual(new UInt256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), v); -// Assert.AreEqual(new UInt256("0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), v); -// Assert.AreEqual(UInt256.Parse("0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), v); -// Assert.True(v < vplus); -// Assert.True(v > vless); +// ClassicAssert.IsTrue(HexEncoding.IsValid("0xff")); + +// ClassicAssert.AreEqual("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", v.ToString()); +// ClassicAssert.AreEqual(new UInt256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), v); +// ClassicAssert.AreEqual(new UInt256("0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), v); +// ClassicAssert.AreEqual(UInt256.Parse("0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), v); +// ClassicAssert.IsTrue(v < vplus); +// ClassicAssert.IsTrue(v > vless); // UInt256 unused; -// Assert.True(UInt256.TryParse("0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); -// Assert.True(UInt256.TryParse("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); -// Assert.True(UInt256.TryParse("00000000ffffFFfFffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); -// Assert.False(UInt256.TryParse("00000000gfffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); -// Assert.False(UInt256.TryParse("100000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); -// Assert.False(UInt256.TryParse("1100000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); +// ClassicAssert.IsTrue(UInt256.TryParse("0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); +// ClassicAssert.IsTrue(UInt256.TryParse("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); +// ClassicAssert.IsTrue(UInt256.TryParse("00000000ffffFFfFffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); +// ClassicAssert.IsFalse(UInt256.TryParse("00000000gfffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); +// ClassicAssert.IsFalse(UInt256.TryParse("100000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); +// ClassicAssert.IsFalse(UInt256.TryParse("1100000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused)); // Assert.Throws(() => UInt256.Parse("1100000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); // Assert.Throws(() => UInt256.Parse("100000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); // UInt256.Parse("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // Assert.Throws(() => UInt256.Parse("000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); -// Assert.True(v >= v2); -// Assert.True(v <= v2); -// Assert.False(v < v2); -// Assert.False(v > v2); +// ClassicAssert.IsTrue(v >= v2); +// ClassicAssert.IsTrue(v <= v2); +// ClassicAssert.IsFalse(v < v2); +// ClassicAssert.IsFalse(v > v2); -// Assert.True(v.ToBytes()[0] == 0xFF); -// Assert.True(v.ToBytes(false)[0] == 0x00); +// ClassicAssert.IsTrue(v.ToBytes()[0] == 0xFF); +// ClassicAssert.IsTrue(v.ToBytes(false)[0] == 0x00); // AssertEquals(v, new UInt256(v.ToBytes())); // AssertEquals(v, new UInt256(v.ToBytes(false), false)); -// Assert.AreEqual(0xFF, v.GetByte(0)); -// Assert.AreEqual(0x00, v.GetByte(31)); -// Assert.AreEqual(0x39, new UInt256("39000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffff").GetByte(31)); +// ClassicAssert.AreEqual(0xFF, v.GetByte(0)); +// ClassicAssert.AreEqual(0x00, v.GetByte(31)); +// ClassicAssert.AreEqual(0x39, new UInt256("39000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffff").GetByte(31)); // Assert.Throws(() => v.GetByte(32)); // } @@ -69,34 +69,34 @@ // SortedDictionary values = new SortedDictionary(); // values.Add(UInt256.Zero, UInt256.Zero); // values.Add(UInt256.One, UInt256.One); -// Assert.AreEqual(UInt256.Zero, values.First().Key); -// Assert.AreEqual(UInt256.One, values.Skip(1).First().Key); -// Assert.AreEqual(-1, UInt256.Zero.CompareTo(UInt256.One)); -// Assert.AreEqual(1, UInt256.One.CompareTo(UInt256.Zero)); -// Assert.AreEqual(1, UInt256.One.CompareTo(null as object)); -// Assert.AreEqual(1, UInt256.Zero.CompareTo(null as object)); - -// Assert.True(null < UInt256.Zero); -// Assert.True(UInt256.Zero > (null as UInt256)); -// Assert.True((null as UInt256) >= (null as UInt256)); -// Assert.True((null as UInt256) == (null as UInt256)); +// ClassicAssert.AreEqual(UInt256.Zero, values.First().Key); +// ClassicAssert.AreEqual(UInt256.One, values.Skip(1).First().Key); +// ClassicAssert.AreEqual(-1, UInt256.Zero.CompareTo(UInt256.One)); +// ClassicAssert.AreEqual(1, UInt256.One.CompareTo(UInt256.Zero)); +// ClassicAssert.AreEqual(1, UInt256.One.CompareTo(null as object)); +// ClassicAssert.AreEqual(1, UInt256.Zero.CompareTo(null as object)); + +// ClassicAssert.IsTrue(null < UInt256.Zero); +// ClassicAssert.IsTrue(UInt256.Zero > (null as UInt256)); +// ClassicAssert.IsTrue((null as UInt256) >= (null as UInt256)); +// ClassicAssert.IsTrue((null as UInt256) == (null as UInt256)); // var values2 = new SortedDictionary { // { UInt160.Zero, UInt160.Zero }, // { UInt160.One, UInt160.One } // }; -// Assert.AreEqual(UInt160.Zero, values2.First().Key); -// Assert.AreEqual(UInt160.One, values2.Skip(1).First().Key); - -// Assert.AreEqual(-1, UInt160.Zero.CompareTo(UInt160.One)); -// Assert.AreEqual(1, UInt160.One.CompareTo(UInt160.Zero)); -// Assert.AreEqual(1, UInt160.One.CompareTo(null as object)); -// Assert.AreEqual(1, UInt160.Zero.CompareTo(null as object)); - -// Assert.True((null as UInt160) < UInt160.Zero); -// Assert.True(UInt160.Zero > (null as UInt160)); -// Assert.True((null as UInt160) >= (null as UInt160)); -// Assert.True((null as UInt160) == (null as UInt160)); +// ClassicAssert.AreEqual(UInt160.Zero, values2.First().Key); +// ClassicAssert.AreEqual(UInt160.One, values2.Skip(1).First().Key); + +// ClassicAssert.AreEqual(-1, UInt160.Zero.CompareTo(UInt160.One)); +// ClassicAssert.AreEqual(1, UInt160.One.CompareTo(UInt160.Zero)); +// ClassicAssert.AreEqual(1, UInt160.One.CompareTo(null as object)); +// ClassicAssert.AreEqual(1, UInt160.Zero.CompareTo(null as object)); + +// ClassicAssert.IsTrue((null as UInt160) < UInt160.Zero); +// ClassicAssert.IsTrue(UInt160.Zero > (null as UInt160)); +// ClassicAssert.IsTrue((null as UInt160) >= (null as UInt160)); +// ClassicAssert.IsTrue((null as UInt160) == (null as UInt160)); // } // //[Test] @@ -119,7 +119,7 @@ // // var vplus = new UInt256("00000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // // stream.ReadWrite(ref v); -// // Assert.NotNull(v); +// // ClassicAssert.NotNull(v); // // ms.Position = 0; // // stream = new BitcoinStream(ms, false); @@ -141,24 +141,24 @@ // // ms = new MemoryStream(); // // stream = new BitcoinStream(ms, true); // // stream.ReadWrite(ref vs); -// // Assert.True(vs.Count == 3); +// // ClassicAssert.IsTrue(vs.Count == 3); // // ms.Position = 0; // // stream = new BitcoinStream(ms, false); // // List vs2 = new List(); // // stream.ReadWrite(ref vs2); -// // Assert.True(vs2.SequenceEqual(vs)); +// // ClassicAssert.IsTrue(vs2.SequenceEqual(vs)); // // ms.Position = 0; // // vs2 = null; // // stream.ReadWrite(ref vs2); -// // Assert.True(vs2.SequenceEqual(vs)); +// // ClassicAssert.IsTrue(vs2.SequenceEqual(vs)); // //} // private void AssertEquals(UInt256 a, UInt256 b) { -// Assert.AreEqual(a, b); -// Assert.AreEqual(a.GetHashCode(), b.GetHashCode()); -// Assert.True(a == b); +// ClassicAssert.AreEqual(a, b); +// ClassicAssert.AreEqual(a.GetHashCode(), b.GetHashCode()); +// ClassicAssert.IsTrue(a == b); // } // } diff --git a/tests/Hydrogen.DApp.Core.Tests/ZipPackageTest.cs b/tests/Hydrogen.DApp.Core.Tests/ZipPackageTest.cs index 656752e07..a7eb39ed4 100644 --- a/tests/Hydrogen.DApp.Core.Tests/ZipPackageTest.cs +++ b/tests/Hydrogen.DApp.Core.Tests/ZipPackageTest.cs @@ -11,6 +11,7 @@ using NUnit.Framework; using Hydrogen; using Hydrogen.DApp.Core.Storage; +using NUnit.Framework.Legacy; namespace VelocityNET.Processing.Tests.Core; @@ -19,12 +20,12 @@ public class ZipPackageTest { [Test] public void CreatePackageOnFirstWrite() { var filename = Tools.FileSystem.GetTempFileName(false); - Assert.IsTrue(!File.Exists(filename)); + ClassicAssert.IsTrue(!File.Exists(filename)); using (new ActionScope(endAction: () => File.Delete(filename))) { var package = new ZipPackage(filename); using (var scope = package.EnterWriteScope()) { - Assert.IsTrue(File.Exists(filename)); + ClassicAssert.IsTrue(File.Exists(filename)); } } } @@ -34,7 +35,7 @@ public void CreatePackageOnFirstWrite() { public void Create_TextFile() { var textData = "alpha beta gamma"; var filename = Tools.FileSystem.GetTempFileName(false); - Assert.IsTrue(!File.Exists(filename)); + ClassicAssert.IsTrue(!File.Exists(filename)); using (new ActionScope(endAction: () => File.Delete(filename))) { var package = new ZipPackage(filename); @@ -43,9 +44,9 @@ public void Create_TextFile() { } using (package.EnterReadScope()) { - Assert.AreEqual(1, package.GetKeys().Count()); + ClassicAssert.AreEqual(1, package.GetKeys().Count()); var value = package.ReadAllText("alpha.txt"); - Assert.AreEqual(textData, value); + ClassicAssert.AreEqual(textData, value); } } } @@ -55,7 +56,7 @@ public void Create_TextFile() { public void Create_BinFile() { var binData = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; var filename = Tools.FileSystem.GetTempFileName(false); - Assert.IsTrue(!File.Exists(filename)); + ClassicAssert.IsTrue(!File.Exists(filename)); using (new ActionScope(endAction: () => File.Delete(filename))) { var package = new ZipPackage(filename); using (package.EnterWriteScope()) { @@ -63,9 +64,9 @@ public void Create_BinFile() { } using (package.EnterReadScope()) { - Assert.AreEqual(1, package.GetKeys().Count()); + ClassicAssert.AreEqual(1, package.GetKeys().Count()); var value = package.ReadAllBytes("alpha.bin"); - Assert.AreEqual(binData, value); + ClassicAssert.AreEqual(binData, value); } } } @@ -75,7 +76,7 @@ public void Create_BinFile() { public void Update_1() { var textData = "alpha beta gamma"; var filename = Tools.FileSystem.GetTempFileName(false); - Assert.IsTrue(!File.Exists(filename)); + ClassicAssert.IsTrue(!File.Exists(filename)); using (new ActionScope(endAction: () => File.Delete(filename))) { var package = new ZipPackage(filename); @@ -88,9 +89,9 @@ public void Update_1() { } using (package.EnterReadScope()) { - Assert.AreEqual(1, package.GetKeys().Count()); + ClassicAssert.AreEqual(1, package.GetKeys().Count()); var value = package.ReadAllText("alpha.txt"); - Assert.AreEqual(textData, value); + ClassicAssert.AreEqual(textData, value); } } } @@ -99,7 +100,7 @@ public void Update_1() { public void Update_2() { var textData = "alpha beta gamma"; var filename = Tools.FileSystem.GetTempFileName(false); - Assert.IsTrue(!File.Exists(filename)); + ClassicAssert.IsTrue(!File.Exists(filename)); using (new ActionScope(endAction: () => File.Delete(filename))) { var package = new ZipPackage(filename); @@ -113,9 +114,9 @@ public void Update_2() { } using (package.EnterReadScope()) { - Assert.AreEqual(2, package.GetKeys().Count()); - Assert.AreEqual(textData, package.ReadAllText("alpha1.txt")); - Assert.AreEqual(textData, package.ReadAllText("alpha2.txt")); + ClassicAssert.AreEqual(2, package.GetKeys().Count()); + ClassicAssert.AreEqual(textData, package.ReadAllText("alpha1.txt")); + ClassicAssert.AreEqual(textData, package.ReadAllText("alpha2.txt")); } } } @@ -131,7 +132,7 @@ public void Complex() { var textData = "alpha beta gamma"; var binData = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; var filename = Tools.FileSystem.GetTempFileName(false); - Assert.IsTrue(!File.Exists(filename)); + ClassicAssert.IsTrue(!File.Exists(filename)); using (new ActionScope(endAction: () => File.Delete(filename))) { var package = ZipPackage.Create(filename); using (package.EnterWriteScope()) { @@ -139,19 +140,19 @@ public void Complex() { package.WriteAllText($"{folder1Name}/{file2Name}", textData); } using (package.EnterWriteScope()) { - Assert.AreEqual(2, package.GetKeys().Count()); - Assert.Contains(file1Name, package.GetKeys().ToArray()); - Assert.Contains($"{folder1Name}/{file2Name}", package.GetKeys().ToArray()); + ClassicAssert.AreEqual(2, package.GetKeys().Count()); + ClassicAssert.Contains(file1Name, package.GetKeys().ToArray()); + ClassicAssert.Contains($"{folder1Name}/{file2Name}", package.GetKeys().ToArray()); package.WriteAllBytes($"{file2Name}", binData); package.WriteAllText($"{folder2Name}/{file2Name}", textData); } using (package.EnterReadScope()) { - Assert.AreEqual(4, package.GetKeys().Count()); - Assert.Contains(file1Name, package.GetKeys().ToArray()); - Assert.Contains($"{folder1Name}/{file2Name}", package.GetKeys().ToArray()); - Assert.Contains(file2Name, package.GetKeys().ToArray()); - Assert.Contains($"{folder2Name}/{file2Name}", package.GetKeys().ToArray()); + ClassicAssert.AreEqual(4, package.GetKeys().Count()); + ClassicAssert.Contains(file1Name, package.GetKeys().ToArray()); + ClassicAssert.Contains($"{folder1Name}/{file2Name}", package.GetKeys().ToArray()); + ClassicAssert.Contains(file2Name, package.GetKeys().ToArray()); + ClassicAssert.Contains($"{folder2Name}/{file2Name}", package.GetKeys().ToArray()); } } } @@ -166,7 +167,7 @@ public void Extract() { var textData = "alpha beta gamma"; var binData = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; var filename = Tools.FileSystem.GetTempFileName(false); - Assert.IsTrue(!File.Exists(filename)); + ClassicAssert.IsTrue(!File.Exists(filename)); using (new ActionScope(endAction: () => File.Delete(filename))) { var package = ZipPackage.Create(filename); using (package.EnterWriteScope()) { @@ -187,37 +188,37 @@ public void Extract() { // root var files = Tools.FileSystem.GetFiles(tmpDir).ToArray(); - Assert.AreEqual(2, files.Length); - Assert.Contains(filename_bin, files); - Assert.Contains(filename_txt, files); - Assert.AreEqual(binData, File.ReadAllBytes(Path.Combine(tmpDir, filename_bin))); - Assert.AreEqual(textData, File.ReadAllText(Path.Combine(tmpDir, filename_txt))); + ClassicAssert.AreEqual(2, files.Length); + ClassicAssert.Contains(filename_bin, files); + ClassicAssert.Contains(filename_txt, files); + ClassicAssert.AreEqual(binData, File.ReadAllBytes(Path.Combine(tmpDir, filename_bin))); + ClassicAssert.AreEqual(textData, File.ReadAllText(Path.Combine(tmpDir, filename_txt))); var dirs = Tools.FileSystem.GetSubDirectories(tmpDir).ToArray(); - Assert.AreEqual(2, dirs.Length); - Assert.Contains(child_dir_1, dirs); - Assert.Contains(child_dir_2, dirs); + ClassicAssert.AreEqual(2, dirs.Length); + ClassicAssert.Contains(child_dir_1, dirs); + ClassicAssert.Contains(child_dir_2, dirs); // subdir 1 var subDir1 = Path.Combine(tmpDir, child_dir_1); files = Tools.FileSystem.GetFiles(subDir1).ToArray(); - Assert.AreEqual(2, files.Length); - Assert.Contains(filename_bin, files); - Assert.Contains(filename_txt, files); - Assert.AreEqual(0, Tools.FileSystem.GetSubDirectories(subDir1).Count()); - Assert.AreEqual(binData, File.ReadAllBytes(Path.Combine(tmpDir, subDir1, filename_bin))); - Assert.AreEqual(textData, File.ReadAllText(Path.Combine(tmpDir, subDir1, filename_txt))); + ClassicAssert.AreEqual(2, files.Length); + ClassicAssert.Contains(filename_bin, files); + ClassicAssert.Contains(filename_txt, files); + ClassicAssert.AreEqual(0, Tools.FileSystem.GetSubDirectories(subDir1).Count()); + ClassicAssert.AreEqual(binData, File.ReadAllBytes(Path.Combine(tmpDir, subDir1, filename_bin))); + ClassicAssert.AreEqual(textData, File.ReadAllText(Path.Combine(tmpDir, subDir1, filename_txt))); // subdir 2 var subDir2 = Path.Combine(tmpDir, child_dir_2); files = Tools.FileSystem.GetFiles(subDir2).ToArray(); - Assert.AreEqual(2, files.Length); - Assert.Contains(filename_bin, files); - Assert.Contains(filename_txt, files); - Assert.AreEqual(0, Tools.FileSystem.GetSubDirectories(subDir2).Count()); - Assert.AreEqual(binData, File.ReadAllBytes(Path.Combine(tmpDir, subDir2, filename_bin))); - Assert.AreEqual(textData, File.ReadAllText(Path.Combine(tmpDir, subDir2, filename_txt))); + ClassicAssert.AreEqual(2, files.Length); + ClassicAssert.Contains(filename_bin, files); + ClassicAssert.Contains(filename_txt, files); + ClassicAssert.AreEqual(0, Tools.FileSystem.GetSubDirectories(subDir2).Count()); + ClassicAssert.AreEqual(binData, File.ReadAllBytes(Path.Combine(tmpDir, subDir2, filename_bin))); + ClassicAssert.AreEqual(textData, File.ReadAllText(Path.Combine(tmpDir, subDir2, filename_txt))); } diff --git a/tests/Hydrogen.DApp.Presentation.Loader.Tests/ComponentTests/BlockMenuTests.cs b/tests/Hydrogen.DApp.Presentation.Loader.Tests/ComponentTests/BlockMenuTests.cs index 45cf71501..a7b614dde 100644 --- a/tests/Hydrogen.DApp.Presentation.Loader.Tests/ComponentTests/BlockMenuTests.cs +++ b/tests/Hydrogen.DApp.Presentation.Loader.Tests/ComponentTests/BlockMenuTests.cs @@ -29,7 +29,7 @@ // public void BlockMenuRenders() { // var component = RenderComponent(); -// Assert.AreEqual(1, component.RenderCount); -// Assert.NotNull(component.Instance); +// ClassicAssert.AreEqual(1, component.RenderCount); +// ClassicAssert.NotNull(component.Instance); // } //} diff --git a/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/AppMenuTests.cs b/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/AppMenuTests.cs index 852d286d1..2b11f9d91 100644 --- a/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/AppMenuTests.cs +++ b/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/AppMenuTests.cs @@ -11,6 +11,7 @@ using Hydrogen.DApp.Presentation.Loader.Plugins; using Hydrogen.DApp.Presentation.Loader.Tests.PluginManagerTests; using Hydrogen.DApp.Presentation.Loader.ViewModels; +using NUnit.Framework.Legacy; namespace Hydrogen.DApp.Presentation.Loader.Tests.NavigationTests; @@ -26,8 +27,8 @@ public void AppMenuInitializedWithApps() { navigationManager.NavigateTo("/"); - Assert.AreSame(appManager.Apps, appsMenuViewModel.Apps); - Assert.AreSame(appManager.SelectedApp, appsMenuViewModel.SelectedApp); - Assert.AreSame(appManager.SelectedApp?.AppBlocks, blockMenuViewModel.AppBlocks); + ClassicAssert.AreSame(appManager.Apps, appsMenuViewModel.Apps); + ClassicAssert.AreSame(appManager.SelectedApp, appsMenuViewModel.SelectedApp); + ClassicAssert.AreSame(appManager.SelectedApp?.AppBlocks, blockMenuViewModel.AppBlocks); } } diff --git a/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/DefaultAppManagerTests.cs b/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/DefaultAppManagerTests.cs index ad758dfee..1b49b2614 100644 --- a/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/DefaultAppManagerTests.cs +++ b/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/DefaultAppManagerTests.cs @@ -12,6 +12,7 @@ using Hydrogen.DApp.Presentation.Loader.Plugins; using Hydrogen.DApp.Presentation.Loader.Tests.PluginManagerTests; using Hydrogen.DApp.Presentation.Plugins; +using NUnit.Framework.Legacy; namespace Hydrogen.DApp.Presentation.Loader.Tests.NavigationTests; @@ -24,7 +25,7 @@ public void AppManagerLoadsPluginApps() { IPluginManager pluginManager = new DefaultPluginManager(locator, new NullLogger()); IAppManager appManager = new DefaultAppManager(pluginManager, new TestNavigationManager()); - Assert.AreEqual(expected.Apps.Count(), appManager.Apps.Count()); + ClassicAssert.AreEqual(expected.Apps.Count(), appManager.Apps.Count()); } [Test] @@ -35,9 +36,9 @@ public void AppManagerSelectsDefaultAppOrNone() { IPluginManager pluginManager = new DefaultPluginManager(locator, new NullLogger()); IAppManager appManager = new DefaultAppManager(pluginManager, new TestNavigationManager()); - Assert.NotNull(appManager.SelectedApp); + ClassicAssert.NotNull(appManager.SelectedApp); - Assert.AreEqual(expected.Apps.First().Name, appManager.SelectedApp.Name); + ClassicAssert.AreEqual(expected.Apps.First().Name, appManager.SelectedApp.Name); } [Test] @@ -50,7 +51,7 @@ public void AppManagerNoSelectedAppOnBadNav() { nav.NavigateTo(nav.Uri + "unknown"); - Assert.Null(appManager.SelectedApp); + ClassicAssert.Null(appManager.SelectedApp); } [Test] @@ -65,8 +66,8 @@ public void NavToApp() { nav.NavigateTo(app.Route); - Assert.NotNull(appManager.SelectedApp); - Assert.AreEqual(app.Name, appManager.SelectedApp.Name); + ClassicAssert.NotNull(appManager.SelectedApp); + ClassicAssert.AreEqual(app.Name, appManager.SelectedApp.Name); } [Test] @@ -82,9 +83,9 @@ public void NavToAppPage() { nav.NavigateTo(page.Route); - Assert.NotNull(appManager.SelectedApp); - Assert.NotNull(appManager.SelectedPage); - Assert.AreEqual(app.Name, appManager.SelectedApp.Name); - Assert.AreEqual(page.Name, appManager.SelectedPage.Name); + ClassicAssert.NotNull(appManager.SelectedApp); + ClassicAssert.NotNull(appManager.SelectedPage); + ClassicAssert.AreEqual(app.Name, appManager.SelectedApp.Name); + ClassicAssert.AreEqual(page.Name, appManager.SelectedPage.Name); } } diff --git a/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/DefaultPluginManagerTests.cs b/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/DefaultPluginManagerTests.cs index 2fce6d2f2..a78c6a88e 100644 --- a/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/DefaultPluginManagerTests.cs +++ b/tests/Hydrogen.DApp.Presentation.Loader.Tests/NavigationTests/DefaultPluginManagerTests.cs @@ -12,6 +12,7 @@ using NUnit.Framework; using Hydrogen.DApp.Presentation.Loader.Plugins; using Hydrogen.DApp.Presentation.Loader.Tests.PluginManagerTests; +using NUnit.Framework.Legacy; namespace Hydrogen.DApp.Presentation.Loader.Tests.NavigationTests; @@ -21,7 +22,7 @@ public void PluginManagerLoadCorrectPlugins() { IPluginLocator locator = new TestPluginLocator(); IPluginManager manager = new DefaultPluginManager(locator, new NullLogger()); - Assert.AreEqual(1, manager.Plugins.Count()); + ClassicAssert.AreEqual(1, manager.Plugins.Count()); } [Test] @@ -32,6 +33,6 @@ public void PluginManagerAddsPluginServices() { var collection = new ServiceCollection(); manager.ConfigureServices(collection); - Assert.AreEqual(1, collection.Count); + ClassicAssert.AreEqual(1, collection.Count); } } diff --git a/tests/Hydrogen.DApp.Presentation.Loader.Tests/PluginTests/MenuItemTests.cs b/tests/Hydrogen.DApp.Presentation.Loader.Tests/PluginTests/MenuItemTests.cs index 989db332c..27e365dcf 100644 --- a/tests/Hydrogen.DApp.Presentation.Loader.Tests/PluginTests/MenuItemTests.cs +++ b/tests/Hydrogen.DApp.Presentation.Loader.Tests/PluginTests/MenuItemTests.cs @@ -10,6 +10,7 @@ using System.Linq; using NUnit.Framework; using Hydrogen.DApp.Presentation.Plugins; +using NUnit.Framework.Legacy; using Assert = NUnit.Framework.Assert; namespace Hydrogen.DApp.Presentation.Loader.Tests.PluginTests; @@ -41,11 +42,11 @@ public void MergeMenuItemsDuplicateRetainsOrig() { List merged = menu1.Merge(menu2).ToList(); - Assert.AreEqual(2, merged.Count); - Assert.AreEqual(menu1[0].Heading, merged[0].Heading); - Assert.AreEqual(menu1[0].Route, merged[0].Route); - Assert.AreEqual(2, merged[0].Children.Count); - Assert.AreEqual(1, merged[1].Children.Count); + ClassicAssert.AreEqual(2, merged.Count); + ClassicAssert.AreEqual(menu1[0].Heading, merged[0].Heading); + ClassicAssert.AreEqual(menu1[0].Route, merged[0].Route); + ClassicAssert.AreEqual(2, merged[0].Children.Count); + ClassicAssert.AreEqual(1, merged[1].Children.Count); } [Test] @@ -60,8 +61,8 @@ public void CopyMenuItemsSameButDifRef() { var copy = menu1.Copy().ToList(); - Assert.AreNotSame(copy, menu1); - Assert.True(menu1[0].Heading == copy[0].Heading); - Assert.True(menu1[0].Children[0].Heading == copy[0].Children[0].Heading); + ClassicAssert.AreNotSame(copy, menu1); + ClassicAssert.IsTrue(menu1[0].Heading == copy[0].Heading); + ClassicAssert.IsTrue(menu1[0].Children[0].Heading == copy[0].Children[0].Heading); } } diff --git a/tests/Hydrogen.DApp.Presentation.Tests/PagedTableViewModelTests.cs b/tests/Hydrogen.DApp.Presentation.Tests/PagedTableViewModelTests.cs index 177e83a66..fd5970d5a 100644 --- a/tests/Hydrogen.DApp.Presentation.Tests/PagedTableViewModelTests.cs +++ b/tests/Hydrogen.DApp.Presentation.Tests/PagedTableViewModelTests.cs @@ -12,6 +12,7 @@ using NUnit.Framework; using Hydrogen.DApp.Presentation.Components.Tables; using Hydrogen.DApp.Presentation.Models; +using NUnit.Framework.Legacy; namespace Hydrogen.DApp.Presentation.Tests; @@ -28,15 +29,15 @@ public void ProgressThroughPagesCorrectly() { vm.PageSize = pageSize; vm.Items = AutoFixture.CreateMany(rowCount).ToList(); - Assert.AreEqual(5, vm.Page.Count()); + ClassicAssert.AreEqual(5, vm.Page.Count()); vm.NextPageAsync(); - Assert.AreEqual(2, vm.CurrentPage); - Assert.AreEqual(5, vm.Page.Count()); + ClassicAssert.AreEqual(2, vm.CurrentPage); + ClassicAssert.AreEqual(5, vm.Page.Count()); vm.NextPageAsync(); - Assert.AreEqual(3, vm.CurrentPage); - Assert.AreEqual(4, vm.Page.Count()); + ClassicAssert.AreEqual(3, vm.CurrentPage); + ClassicAssert.AreEqual(4, vm.Page.Count()); Assert.ThrowsAsync(vm.NextPageAsync); } @@ -58,7 +59,7 @@ public void NextAndPrevious() { vm.PrevPageAsync(); vm.PrevPageAsync(); - Assert.AreEqual(first, vm.Page); + ClassicAssert.AreEqual(first, vm.Page); } [Test] @@ -68,18 +69,18 @@ public void HasNextAsExpected() { Items = AutoFixture.CreateMany(9).ToList() }; - Assert.IsTrue(vm.HasNextPage); - Assert.IsFalse(vm.HasPrevPage); + ClassicAssert.IsTrue(vm.HasNextPage); + ClassicAssert.IsFalse(vm.HasPrevPage); vm.NextPageAsync(); - Assert.IsTrue(vm.HasNextPage); - Assert.IsTrue(vm.HasPrevPage); + ClassicAssert.IsTrue(vm.HasNextPage); + ClassicAssert.IsTrue(vm.HasPrevPage); vm.NextPageAsync(); - Assert.IsFalse(vm.HasNextPage); - Assert.IsTrue(vm.HasPrevPage); + ClassicAssert.IsFalse(vm.HasNextPage); + ClassicAssert.IsTrue(vm.HasPrevPage); } [Test] @@ -89,15 +90,15 @@ public void ChangePageSizeSetsPage() { Items = AutoFixture.CreateMany(10).ToList() }; - Assert.AreEqual(10, vm.TotalPages); - Assert.AreEqual(1, vm.CurrentPage); + ClassicAssert.AreEqual(10, vm.TotalPages); + ClassicAssert.AreEqual(1, vm.CurrentPage); vm.NextPageAsync(); - Assert.AreEqual(2, vm.CurrentPage); + ClassicAssert.AreEqual(2, vm.CurrentPage); vm.PageSize = 3; - Assert.AreEqual(1, vm.CurrentPage); + ClassicAssert.AreEqual(1, vm.CurrentPage); } } diff --git a/tests/Hydrogen.DApp.Presentation.Tests/RapidTableViewModelTests.cs b/tests/Hydrogen.DApp.Presentation.Tests/RapidTableViewModelTests.cs index fa6d8d610..3fcb43b22 100644 --- a/tests/Hydrogen.DApp.Presentation.Tests/RapidTableViewModelTests.cs +++ b/tests/Hydrogen.DApp.Presentation.Tests/RapidTableViewModelTests.cs @@ -10,6 +10,7 @@ using System.Threading.Tasks; using NUnit.Framework; using Hydrogen.DApp.Presentation.Components.Tables; +using NUnit.Framework.Legacy; namespace Hydrogen.DApp.Presentation.Tests; @@ -32,7 +33,7 @@ public async Task InitVmPopulatesItems() { await vm.InitAsync(); await Task.Delay(10); - Assert.AreEqual(10, vm.Items.Count); + ClassicAssert.AreEqual(10, vm.Items.Count); } [Test] @@ -45,6 +46,6 @@ public async Task TotalItemsLimitsItems() { await vm.InitAsync(); await Task.Delay(10); - Assert.AreEqual(2, vm.Items.Count); + ClassicAssert.AreEqual(2, vm.Items.Count); } } diff --git a/tests/Hydrogen.DApp.Presentation.Tests/VirtualPagedTableViewModelTests.cs b/tests/Hydrogen.DApp.Presentation.Tests/VirtualPagedTableViewModelTests.cs index ac3285ed9..529bf43d4 100644 --- a/tests/Hydrogen.DApp.Presentation.Tests/VirtualPagedTableViewModelTests.cs +++ b/tests/Hydrogen.DApp.Presentation.Tests/VirtualPagedTableViewModelTests.cs @@ -14,6 +14,7 @@ using NUnit.Framework; using Hydrogen.DApp.Presentation.Components.Tables; using Hydrogen.DApp.Presentation.Models; +using NUnit.Framework.Legacy; namespace Hydrogen.DApp.Presentation.Tests; @@ -43,9 +44,9 @@ public async Task FirstPageOnInit() { await vm.InitAsync(); - Assert.AreEqual(vm.PageSize, vm.Page.Count()); - Assert.AreEqual(service.TotalItems, vm.TotalItems); - Assert.AreEqual((int)Math.Ceiling((double)service.TotalItems / vm.PageSize), vm.TotalPages); + ClassicAssert.AreEqual(vm.PageSize, vm.Page.Count()); + ClassicAssert.AreEqual(service.TotalItems, vm.TotalItems); + ClassicAssert.AreEqual((int)Math.Ceiling((double)service.TotalItems / vm.PageSize), vm.TotalPages); } [Test] @@ -59,8 +60,8 @@ public async Task NextAndPrevious() { await vm.InitAsync(); - Assert.AreEqual(4, vm.TotalPages); - Assert.AreEqual(10, vm.TotalItems); + ClassicAssert.AreEqual(4, vm.TotalPages); + ClassicAssert.AreEqual(10, vm.TotalItems); await vm.NextPageAsync(); await vm.NextPageAsync(); @@ -69,7 +70,7 @@ public async Task NextAndPrevious() { await vm.PrevPageAsync(); await vm.PrevPageAsync(); - Assert.AreEqual(1, vm.CurrentPage); + ClassicAssert.AreEqual(1, vm.CurrentPage); } [Test] @@ -83,15 +84,15 @@ public async Task ChangePageSizeSetsPage() { await vm.InitAsync(); - Assert.AreEqual(10, vm.TotalPages); - Assert.AreEqual(1, vm.CurrentPage); + ClassicAssert.AreEqual(10, vm.TotalPages); + ClassicAssert.AreEqual(1, vm.CurrentPage); await vm.NextPageAsync(); - Assert.AreEqual(2, vm.CurrentPage); + ClassicAssert.AreEqual(2, vm.CurrentPage); await vm.SetPageSizeAsync(3); - Assert.AreEqual(1, vm.CurrentPage); + ClassicAssert.AreEqual(1, vm.CurrentPage); } } diff --git a/tests/Hydrogen.DApp.Presentation.Tests/Wizard/DefaultWizardTests.cs b/tests/Hydrogen.DApp.Presentation.Tests/Wizard/DefaultWizardTests.cs index 158d39f68..de8c64050 100644 --- a/tests/Hydrogen.DApp.Presentation.Tests/Wizard/DefaultWizardTests.cs +++ b/tests/Hydrogen.DApp.Presentation.Tests/Wizard/DefaultWizardTests.cs @@ -11,6 +11,7 @@ using System.Threading.Tasks; using NUnit.Framework; using Hydrogen.DApp.Presentation.Components.Wizard; +using NUnit.Framework.Legacy; namespace Hydrogen.DApp.Presentation.Tests.Wizard; @@ -20,9 +21,9 @@ public void Initialized() { IWizard wizard = new DefaultWizard("test", new List { typeof(object) }, true, null, null); - Assert.NotNull(wizard.CurrentStep); - Assert.IsFalse(wizard.HasNext); - Assert.IsFalse(wizard.HasPrevious); + ClassicAssert.NotNull(wizard.CurrentStep); + ClassicAssert.IsFalse(wizard.HasNext); + ClassicAssert.IsFalse(wizard.HasPrevious); } [Test] @@ -34,20 +35,20 @@ public void NextAsync() { null, null); - Assert.IsTrue(wizard.HasNext); - Assert.IsFalse(wizard.HasPrevious); + ClassicAssert.IsTrue(wizard.HasNext); + ClassicAssert.IsFalse(wizard.HasPrevious); wizard.Next(); - Assert.IsTrue(wizard.HasNext); - Assert.IsTrue(wizard.HasPrevious); - Assert.NotNull(wizard.CurrentStep); + ClassicAssert.IsTrue(wizard.HasNext); + ClassicAssert.IsTrue(wizard.HasPrevious); + ClassicAssert.NotNull(wizard.CurrentStep); wizard.Next(); - Assert.IsFalse(wizard.HasNext); - Assert.IsTrue(wizard.HasPrevious); - Assert.NotNull(wizard.CurrentStep); + ClassicAssert.IsFalse(wizard.HasNext); + ClassicAssert.IsTrue(wizard.HasPrevious); + ClassicAssert.NotNull(wizard.CurrentStep); } [Test] @@ -56,17 +57,17 @@ public void InjectStep() { new DefaultWizard("Test", new List { typeof(int) }, new object(), null, null); - Assert.AreEqual(typeof(int), wizard.CurrentStep); + ClassicAssert.AreEqual(typeof(int), wizard.CurrentStep); wizard.Next(); - Assert.IsFalse(wizard.HasNext); + ClassicAssert.IsFalse(wizard.HasNext); wizard.UpdateSteps(StepUpdateType.Inject, new[] { typeof(double) }); - Assert.IsTrue(wizard.HasNext); + ClassicAssert.IsTrue(wizard.HasNext); bool result = wizard.Next(); - Assert.IsTrue(result); - Assert.AreEqual(typeof(double), wizard.CurrentStep); - Assert.IsFalse(wizard.HasNext); + ClassicAssert.IsTrue(result); + ClassicAssert.AreEqual(typeof(double), wizard.CurrentStep); + ClassicAssert.IsFalse(wizard.HasNext); } [Test] @@ -74,20 +75,20 @@ public void InjectStepTwiceDedupe() { IWizard wizard = new DefaultWizard("Test", new List { typeof(int) }, new object(), null, null); - Assert.AreEqual(typeof(int), wizard.CurrentStep); - Assert.IsFalse(wizard.HasNext); + ClassicAssert.AreEqual(typeof(int), wizard.CurrentStep); + ClassicAssert.IsFalse(wizard.HasNext); wizard.UpdateSteps(StepUpdateType.Inject, new[] { typeof(double) }); wizard.UpdateSteps(StepUpdateType.Inject, new[] { typeof(double) }); - Assert.IsTrue(wizard.HasNext); + ClassicAssert.IsTrue(wizard.HasNext); bool result = wizard.Next(); bool secondResult = wizard.Next(); - Assert.IsTrue(result); - Assert.IsFalse(secondResult); - Assert.AreEqual(typeof(double), wizard.CurrentStep); - Assert.IsFalse(wizard.HasNext); + ClassicAssert.IsTrue(result); + ClassicAssert.IsFalse(secondResult); + ClassicAssert.AreEqual(typeof(double), wizard.CurrentStep); + ClassicAssert.IsFalse(wizard.HasNext); } [Test] @@ -102,9 +103,9 @@ public void ReplaceAllNextSteps() { wizard.UpdateSteps(StepUpdateType.ReplaceAllNext, new[] { typeof(bool) }); bool result = wizard.Next(); - Assert.IsTrue(result); - Assert.AreEqual(typeof(bool), wizard.CurrentStep); - Assert.IsFalse(wizard.HasNext); + ClassicAssert.IsTrue(result); + ClassicAssert.AreEqual(typeof(bool), wizard.CurrentStep); + ClassicAssert.IsFalse(wizard.HasNext); } [Test] @@ -118,8 +119,8 @@ public void RemoveNext() { wizard.UpdateSteps(StepUpdateType.RemoveNext, new[] { typeof(decimal), typeof(double) }); - Assert.IsFalse(wizard.HasNext); - Assert.AreEqual(typeof(int), wizard.CurrentStep); + ClassicAssert.IsFalse(wizard.HasNext); + ClassicAssert.AreEqual(typeof(int), wizard.CurrentStep); } [Test] @@ -133,8 +134,8 @@ public void ReplaceAll() { wizard.UpdateSteps(StepUpdateType.ReplaceAll, new[] { typeof(decimal), typeof(double) }); - Assert.AreEqual(typeof(decimal), wizard.CurrentStep); - Assert.IsTrue(wizard.HasNext); + ClassicAssert.AreEqual(typeof(decimal), wizard.CurrentStep); + ClassicAssert.IsTrue(wizard.HasNext); } [Test] @@ -147,7 +148,7 @@ public async Task FinishAsyncFalse() { null); bool result = await wizard.FinishAsync(); - Assert.IsFalse(result); + ClassicAssert.IsFalse(result); } [Test] @@ -160,7 +161,7 @@ public async Task FinishAsyncTrue() { null); bool result = await wizard.FinishAsync(); - Assert.IsTrue(result); + ClassicAssert.IsTrue(result); } [Test] @@ -173,7 +174,7 @@ public async Task CancelAsyncFalse() { x => Task.FromResult>(x)); bool result = await wizard.CancelAsync(); - Assert.IsFalse(result); + ClassicAssert.IsFalse(result); } [Test] @@ -186,6 +187,6 @@ public async Task CancelAsyncTrue() { x => Task.FromResult>(x)); bool result = await wizard.CancelAsync(); - Assert.IsTrue(result); + ClassicAssert.IsTrue(result); } } diff --git a/tests/Hydrogen.Data.Tests/DACScopeTests.cs b/tests/Hydrogen.Data.Tests/DACScopeTests.cs index 5f22a772a..aa362fa4d 100644 --- a/tests/Hydrogen.Data.Tests/DACScopeTests.cs +++ b/tests/Hydrogen.Data.Tests/DACScopeTests.cs @@ -10,6 +10,7 @@ using System.Threading.Tasks; using NUnit.Framework; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Data.Tests; @@ -23,7 +24,7 @@ public void ReuseConnection_SameDAC_1(DBMSType dbmsType) { using (var dac = EnterCreateDatabaseScope(dbmsType, TestTables.BasicTable)) { using (var scope = dac.BeginScope(false)) { using (var scope2 = dac.BeginScope(false)) { - Assert.AreSame(scope.Connection, scope2.Connection); + ClassicAssert.AreSame(scope.Connection, scope2.Connection); } } } @@ -35,7 +36,7 @@ public void ReuseConnection_SameDAC_2(DBMSType dbmsType) { using (var dac = EnterCreateDatabaseScope(dbmsType, TestTables.BasicTable)) { using (var scope = dac.BeginScope(false)) { using (var scope2 = dac.BeginScope(true)) { - Assert.AreSame(scope.Connection, scope2.Connection); + ClassicAssert.AreSame(scope.Connection, scope2.Connection); } } } @@ -47,7 +48,7 @@ public void ReuseConnection_SameDAC_3(DBMSType dbmsType) { using (var dac = EnterCreateDatabaseScope(dbmsType, TestTables.BasicTable)) { using (var scope = dac.BeginScope(true)) { using (var scope2 = dac.BeginScope(false)) { - Assert.AreSame(scope.Connection, scope2.Connection); + ClassicAssert.AreSame(scope.Connection, scope2.Connection); } } } @@ -59,7 +60,7 @@ public void ReuseConnection_SameDAC_4(DBMSType dbmsType) { using (var dac = EnterCreateDatabaseScope(dbmsType, TestTables.BasicTable)) { using (var scope = dac.BeginScope(true)) { using (var scope2 = dac.BeginScope(true)) { - Assert.AreSame(scope.Connection, scope2.Connection); + ClassicAssert.AreSame(scope.Connection, scope2.Connection); } } } @@ -73,7 +74,7 @@ public void ReuseConnection_DifferentDAC_1(DBMSType dbmsType) { var dac2 = DuplicateDAC(dac); using (var scope = dac.BeginScope(false)) { using (var scope2 = dac2.BeginScope(false)) { - Assert.AreSame(scope.Connection, scope2.Connection); + ClassicAssert.AreSame(scope.Connection, scope2.Connection); } } } @@ -86,7 +87,7 @@ public void ReuseConnection_DifferentDAC_2(DBMSType dbmsType) { var dac2 = DuplicateDAC(dac); using (var scope = dac.BeginScope(false)) { using (var scope2 = dac2.BeginScope(true)) { - Assert.AreSame(scope.Connection, scope2.Connection); + ClassicAssert.AreSame(scope.Connection, scope2.Connection); } } } @@ -99,7 +100,7 @@ public void ReuseConnection_DifferentDAC_3(DBMSType dbmsType) { var dac2 = DuplicateDAC(dac); using (var scope = dac.BeginScope(true)) { using (var scope2 = dac2.BeginScope(false)) { - Assert.AreSame(scope.Connection, scope2.Connection); + ClassicAssert.AreSame(scope.Connection, scope2.Connection); } } } @@ -112,7 +113,7 @@ public void ReuseConnection_DifferentDAC_4(DBMSType dbmsType) { var dac2 = DuplicateDAC(dac); using (var scope = dac.BeginScope(true)) { using (var scope2 = dac2.BeginScope(true)) { - Assert.AreSame(scope.Connection, scope2.Connection); + ClassicAssert.AreSame(scope.Connection, scope2.Connection); } } } @@ -143,7 +144,7 @@ public async Task ReuseConnection_DifferentDAC_Async2(DBMSType dbmsType) { private async Task AssertConnectionPropagationAsync(IDbConnection expectedConnectionObj, IDAC dac2) { using (var scope2 = dac2.BeginScope(true)) { - Assert.AreSame(expectedConnectionObj, scope2.Connection); + ClassicAssert.AreSame(expectedConnectionObj, scope2.Connection); } } @@ -168,7 +169,7 @@ public void CommitTransaction_1(DBMSType dbmsType) { dac.Insert("BasicTable", new[] { new ColumnValue("ID", 1) }); scope.Commit(); } - Assert.AreEqual(1, dac.Count("BasicTable")); + ClassicAssert.AreEqual(1, dac.Count("BasicTable")); } } [Test] @@ -180,7 +181,7 @@ public void RollbackTransaction(DBMSType dbmsType) { dac.Insert("BasicTable", new[] { new ColumnValue("ID", 1) }); scope.Rollback(); } - Assert.AreEqual(0, dac.Count("BasicTable")); + ClassicAssert.AreEqual(0, dac.Count("BasicTable")); } } @@ -200,7 +201,7 @@ public void RollbackTransaction_NestedScope(DBMSType dbmsType) { } scope.Commit(); } - Assert.AreEqual(0, dac.Count("BasicTable")); + ClassicAssert.AreEqual(0, dac.Count("BasicTable")); } } @@ -221,7 +222,7 @@ public void ConsequtiveTransactions(DBMSType dbmsType) { scope.Commit(); } - Assert.AreEqual(2, dac.Count("BasicTable")); + ClassicAssert.AreEqual(2, dac.Count("BasicTable")); } } @@ -244,7 +245,7 @@ public void ConsequtiveTransactionsNested_1(DBMSType dbmsType) { } scope1.Commit(); } - Assert.AreEqual(0, dac.Count("BasicTable")); + ClassicAssert.AreEqual(0, dac.Count("BasicTable")); } } @@ -267,7 +268,7 @@ public void ConsequtiveTransactionsNested_2(DBMSType dbmsType) { } scope1.Rollback(); } - Assert.AreEqual(0, dac.Count("BasicTable")); + ClassicAssert.AreEqual(0, dac.Count("BasicTable")); } } @@ -290,7 +291,7 @@ public void ConsequtiveTransactionsNested_3(DBMSType dbmsType) { } scope1.Commit(); } - Assert.AreEqual(3, dac.Count("BasicTable")); + ClassicAssert.AreEqual(3, dac.Count("BasicTable")); } } @@ -318,7 +319,7 @@ public void ConsequtiveTransactionsNested_4(DBMSType dbmsType) { dac.Insert("BasicTable", new[] { new ColumnValue("ID", 4) }); scope0.Commit(); } - Assert.AreEqual(1, dac.Count("BasicTable")); + ClassicAssert.AreEqual(1, dac.Count("BasicTable")); } } diff --git a/tests/Hydrogen.Data.Tests/MSSQLToolTest.cs b/tests/Hydrogen.Data.Tests/MSSQLToolTest.cs index 97d9fd430..b8fe7778f 100644 --- a/tests/Hydrogen.Data.Tests/MSSQLToolTest.cs +++ b/tests/Hydrogen.Data.Tests/MSSQLToolTest.cs @@ -8,6 +8,7 @@ using System; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Data.Tests; @@ -21,7 +22,7 @@ public class MSSQLToolTest { [Test] public void Exists_False() { - Assert.IsFalse(Tools.MSSQL.Exists(Server, "__!__No_Database_Should_Ever_be_Called_This__!", Username, Password)); + ClassicAssert.IsFalse(Tools.MSSQL.Exists(Server, "__!__No_Database_Should_Ever_be_Called_This__!", Username, Password)); } [Test] @@ -29,7 +30,7 @@ public void Create() { var dbName = Guid.NewGuid().ToStrictAlphaString(); try { Tools.MSSQL.CreateDatabase(Server, dbName, Username, Password); - Assert.IsTrue(Tools.MSSQL.Exists(Server, dbName, Username, Password)); + ClassicAssert.IsTrue(Tools.MSSQL.Exists(Server, dbName, Username, Password)); } finally { Tools.MSSQL.DropDatabase(Server, dbName, Username, Password); } @@ -73,9 +74,9 @@ public void Create_DuplicateError() { public void Drop() { var dbName = Guid.NewGuid().ToStrictAlphaString(); Tools.MSSQL.CreateDatabase(Server, dbName, Username, Password); - Assert.IsTrue(Tools.MSSQL.Exists(Server, dbName, Username, Password)); + ClassicAssert.IsTrue(Tools.MSSQL.Exists(Server, dbName, Username, Password)); Tools.MSSQL.DropDatabase(Server, dbName, Username, Password); - Assert.IsFalse(Tools.MSSQL.Exists(Server, dbName, Username, Password)); + ClassicAssert.IsFalse(Tools.MSSQL.Exists(Server, dbName, Username, Password)); } [Test] diff --git a/tests/Hydrogen.Data.Tests/SqliteDACTests.cs b/tests/Hydrogen.Data.Tests/SqliteDACTests.cs index f3c8939e2..90b45c112 100644 --- a/tests/Hydrogen.Data.Tests/SqliteDACTests.cs +++ b/tests/Hydrogen.Data.Tests/SqliteDACTests.cs @@ -11,6 +11,7 @@ using NUnit.Framework; using System.IO; using Hydrogen.Data.Tests.Properties; +using NUnit.Framework.Legacy; namespace Hydrogen.Data.Tests; @@ -30,7 +31,7 @@ public void CreateDatabase() { public void Connection_CreateOpen() { var dac = Tools.Sqlite.Open(DBFile); using (var conn = dac.CreateOpenConnection()) { - Assert.AreEqual(conn.State, ConnectionState.Open); + ClassicAssert.AreEqual(conn.State, ConnectionState.Open); } } @@ -38,7 +39,7 @@ public void Connection_CreateOpen() { public void Connection_CreateClosed() { var dac = Tools.Sqlite.Open(DBFile); using (var conn = dac.CreateConnection()) { - Assert.AreEqual(conn.State, ConnectionState.Closed); + ClassicAssert.AreEqual(conn.State, ConnectionState.Closed); } } @@ -58,7 +59,7 @@ Data1 UNIQUEIDENTIFIER NOT NULL dac.ExecuteNonQuery(tableDDL); dac.Insert("Table", new[] { new ColumnValue("Data1", guid) }); var read = dac.Select("Table", new[] { "Data1" }).Single().Get(0); - Assert.AreEqual(guid, read); + ClassicAssert.AreEqual(guid, read); } finally { if (File.Exists(dbFile)) File.Delete(dbFile); @@ -83,7 +84,7 @@ Data1 UNIQUEIDENTIFIER NOT NULL dac.Insert("Table", new[] { new ColumnValue("Data1", guid) }); var read = dac.Select("Table", new[] { "Data1" }, columnMatches: new[] { new ColumnValue("Data1", guid), }).Single().Get(0); - Assert.AreEqual(guid, read); + ClassicAssert.AreEqual(guid, read); } finally { if (File.Exists(dbFile)) @@ -111,7 +112,7 @@ Data1 UNIQUEIDENTIFIER NOT NULL dac.Insert("Table", new[] { new ColumnValue("Data1", emptyGuid) }); var read = dac.Select("Table", new[] { "Data1" }, columnMatches: new[] { new ColumnValue("Data1", emptyGuid), }).Single().Get(0); - Assert.AreEqual(emptyGuid, read); + ClassicAssert.AreEqual(emptyGuid, read); } finally { if (File.Exists(dbFile)) diff --git a/tests/Hydrogen.Data.Tests/SqliteToolTest.cs b/tests/Hydrogen.Data.Tests/SqliteToolTest.cs index 528bad2c1..881f8af7a 100644 --- a/tests/Hydrogen.Data.Tests/SqliteToolTest.cs +++ b/tests/Hydrogen.Data.Tests/SqliteToolTest.cs @@ -9,6 +9,7 @@ using System; using NUnit.Framework; using System.IO; +using NUnit.Framework.Legacy; namespace Hydrogen.Data.Tests; @@ -16,7 +17,7 @@ namespace Hydrogen.Data.Tests; public class SqliteToolTest { [Test] public void ExistsByFilePath_False() { - Assert.IsFalse(Tools.Sqlite.ExistsByPath(GenerateTempFilename())); + ClassicAssert.IsFalse(Tools.Sqlite.ExistsByPath(GenerateTempFilename())); } [Test] @@ -24,7 +25,7 @@ public void ExistsByFilePath_True() { var path = GenerateTempFilename(); try { var dac1 = Tools.Sqlite.Create(path); - Assert.IsTrue(Tools.Sqlite.ExistsByPath(path)); + ClassicAssert.IsTrue(Tools.Sqlite.ExistsByPath(path)); } finally { if (File.Exists(path)) File.Delete(path); @@ -38,7 +39,7 @@ public void Create() { try { var dac1 = Tools.Sqlite.Create(path); System.Console.WriteLine("File Size is " + Tools.FileSystem.GetFileSize(path)); - Assert.IsTrue(File.Exists(path)); + ClassicAssert.IsTrue(File.Exists(path)); } finally { if (File.Exists(path)) File.Delete(path); @@ -51,7 +52,7 @@ public void Create_Skip() { try { var dac1 = Tools.Sqlite.Create(path); Assert.DoesNotThrow(() => Tools.Sqlite.Create(path, existsPolicy: AlreadyExistsPolicy.Skip)); - Assert.IsTrue(File.Exists(path)); + ClassicAssert.IsTrue(File.Exists(path)); } finally { if (File.Exists(path)) File.Delete(path); @@ -64,7 +65,7 @@ public void Create_Overwrite() { try { var dac1 = Tools.Sqlite.Create(path); Assert.DoesNotThrow(() => Tools.Sqlite.Create(path, existsPolicy: AlreadyExistsPolicy.Overwrite)); - Assert.IsTrue(File.Exists(path)); + ClassicAssert.IsTrue(File.Exists(path)); } finally { if (File.Exists(path)) File.Delete(path); @@ -77,7 +78,7 @@ public void Create_Throws() { try { var dac1 = Tools.Sqlite.Create(path); Assert.Catch(() => Tools.Sqlite.Create(path)); - Assert.IsTrue(File.Exists(path)); + ClassicAssert.IsTrue(File.Exists(path)); } finally { if (File.Exists(path)) File.Delete(path); @@ -112,7 +113,7 @@ public void Create_PageSize_4096() { try { var dac1 = Tools.Sqlite.Create(path, pageSize: 4096); var pageSize = dac1.ExecuteScalar("PRAGMA page_size;"); - Assert.AreEqual(4096, pageSize); + ClassicAssert.AreEqual(4096, pageSize); } finally { if (File.Exists(path)) File.Delete(path); @@ -125,7 +126,7 @@ public void Create_PageSize_32768() { try { var dac1 = Tools.Sqlite.Create(path, pageSize: 32768); var pageSize = dac1.ExecuteScalar("PRAGMA page_size;"); - Assert.AreEqual(32768, pageSize); + ClassicAssert.AreEqual(32768, pageSize); } finally { if (File.Exists(path)) File.Delete(path); @@ -137,9 +138,9 @@ public void Drop() { var path = GenerateTempFilename(); try { var dac = Tools.Sqlite.Create(path); - Assert.IsTrue(Tools.Sqlite.ExistsByPath(path)); + ClassicAssert.IsTrue(Tools.Sqlite.ExistsByPath(path)); Tools.Sqlite.Drop(path); - Assert.IsFalse(Tools.Sqlite.ExistsByPath(path)); + ClassicAssert.IsFalse(Tools.Sqlite.ExistsByPath(path)); } finally { if (File.Exists(path)) File.Delete(path); diff --git a/tests/Hydrogen.Data.Tests/TransactionScopeCompatibilityTests.cs b/tests/Hydrogen.Data.Tests/TransactionScopeCompatibilityTests.cs index de40faff1..c90c25496 100644 --- a/tests/Hydrogen.Data.Tests/TransactionScopeCompatibilityTests.cs +++ b/tests/Hydrogen.Data.Tests/TransactionScopeCompatibilityTests.cs @@ -9,6 +9,7 @@ using System.Transactions; using NUnit.Framework; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Data.Tests; @@ -25,7 +26,7 @@ public void Commit_AutoEnlist(DBMSType dbmsType) { txn.Complete(); } } - Assert.AreEqual(1, dac.Count("BasicTable")); + ClassicAssert.AreEqual(1, dac.Count("BasicTable")); } } @@ -42,7 +43,7 @@ public void Commit_ManualEnlist(DBMSType dbmsType) { txn.Complete(); } } - Assert.AreEqual(1, dac.Count("BasicTable")); + ClassicAssert.AreEqual(1, dac.Count("BasicTable")); } } @@ -55,7 +56,7 @@ public void Rollback_AutoEnlist(DBMSType dbmsType) { dac.Insert("BasicTable", new[] { new ColumnValue("ID", 1) }); } } - Assert.AreEqual(0, dac.Count("BasicTable")); + ClassicAssert.AreEqual(0, dac.Count("BasicTable")); } } @@ -71,7 +72,7 @@ public void Rollback_ManualEnlist_1(DBMSType dbmsType) { dac.Insert("BasicTable", new[] { new ColumnValue("ID", 1) }); } } - Assert.AreEqual(0, dac.Count("BasicTable")); + ClassicAssert.AreEqual(0, dac.Count("BasicTable")); } } @@ -86,7 +87,7 @@ public void Rollback_ManualEnlist_2(DBMSType dbmsType) { } dac.Insert("BasicTable", new[] { new ColumnValue("ID", 2) }); } - Assert.AreEqual(1, dac.Count("BasicTable")); + ClassicAssert.AreEqual(1, dac.Count("BasicTable")); } } @@ -106,7 +107,7 @@ public void MixedScope_SystemThenDAC_1(DBMSType dbmsType) { dac.Insert("BasicTable", new[] { new ColumnValue("ID", 2) }); scope.Commit(); } - Assert.AreEqual(2, dac.Count("BasicTable")); + ClassicAssert.AreEqual(2, dac.Count("BasicTable")); } } @@ -124,7 +125,7 @@ public void MixedScope_SystemThenDAC_2(DBMSType dbmsType) { dac.Insert("BasicTable", new[] { new ColumnValue("ID", 2) }); scope.Commit(); } - Assert.AreEqual(1, dac.Count("BasicTable")); + ClassicAssert.AreEqual(1, dac.Count("BasicTable")); } } @@ -144,7 +145,7 @@ public void MixedScope_DACThenSystem_1(DBMSType dbmsType) { tx.Complete(); } } - Assert.AreEqual(2, dac.Count("BasicTable")); + ClassicAssert.AreEqual(2, dac.Count("BasicTable")); } } @@ -163,7 +164,7 @@ public void MixedScope_DACThenSystem_2(DBMSType dbmsType) { dac.Insert("BasicTable", new[] { new ColumnValue("ID", 1) }); } } - Assert.AreEqual(1, dac.Count("BasicTable")); + ClassicAssert.AreEqual(1, dac.Count("BasicTable")); } } diff --git a/tests/Hydrogen.NET.Tests/Math/MathCompilerParserTests.cs b/tests/Hydrogen.NET.Tests/Math/MathCompilerParserTests.cs index 0ccb622b8..8f876ffc5 100644 --- a/tests/Hydrogen.NET.Tests/Math/MathCompilerParserTests.cs +++ b/tests/Hydrogen.NET.Tests/Math/MathCompilerParserTests.cs @@ -9,6 +9,7 @@ using NUnit.Framework; using System.IO; using Hydrogen.Maths.Compiler; +using NUnit.Framework.Legacy; namespace Hydrogen.UnitTests; @@ -27,23 +28,23 @@ public void TestTreeStructure() { Parser parser = new Parser(new Scanner(new StringReader(exp))); SyntaxTree tree = parser.ParseExpression(); // (-x) - y - z - Assert.IsInstanceOf(typeof(BinaryOperatorTree), tree); - Assert.AreEqual(Operator.Subtraction, ((BinaryOperatorTree)tree).Operator); - Assert.IsInstanceOf(typeof(BinaryOperatorTree), + ClassicAssert.IsInstanceOf(typeof(BinaryOperatorTree), tree); + ClassicAssert.AreEqual(Operator.Subtraction, ((BinaryOperatorTree)tree).Operator); + ClassicAssert.IsInstanceOf(typeof(BinaryOperatorTree), ((BinaryOperatorTree)tree).LeftHandSide); - Assert.AreEqual(Operator.Subtraction, + ClassicAssert.AreEqual(Operator.Subtraction, ((BinaryOperatorTree)((BinaryOperatorTree)tree).LeftHandSide).Operator); - Assert.IsInstanceOf(typeof(UnaryOperatorTree), + ClassicAssert.IsInstanceOf(typeof(UnaryOperatorTree), ((BinaryOperatorTree)((BinaryOperatorTree)tree).LeftHandSide).LeftHandSide); - Assert.IsInstanceOf(typeof(FactorTree), + ClassicAssert.IsInstanceOf(typeof(FactorTree), ((BinaryOperatorTree)((BinaryOperatorTree)tree).LeftHandSide).RightHandSide); - Assert.AreEqual(Operator.UnaryMinus, + ClassicAssert.AreEqual(Operator.UnaryMinus, ((UnaryOperatorTree)((BinaryOperatorTree)((BinaryOperatorTree)tree).LeftHandSide).LeftHandSide).Operator); ; - Assert.IsInstanceOf(typeof(FactorTree), + ClassicAssert.IsInstanceOf(typeof(FactorTree), ((UnaryOperatorTree)((BinaryOperatorTree)((BinaryOperatorTree)tree).LeftHandSide).LeftHandSide).Operand); ; - Assert.IsInstanceOf(typeof(FactorTree), + ClassicAssert.IsInstanceOf(typeof(FactorTree), ((BinaryOperatorTree)tree).RightHandSide); } @@ -52,7 +53,7 @@ public void TestUnaryAndPower() { string exp = "-x^2.5E-1"; Parser parser = new Parser(new Scanner(new StringReader(exp))); SyntaxTree tree = parser.ParseExpression(); - Assert.AreEqual("UnaryMinus(Power(Identifier(x),Scalar(2.5E-1)))", tree.ToString()); + ClassicAssert.AreEqual("UnaryMinus(Power(Identifier(x),Scalar(2.5E-1)))", tree.ToString()); } [Test] @@ -60,7 +61,7 @@ public void TestUnaryAndMultiplication() { string exp = "-x*-y"; Parser parser = new Parser(new Scanner(new StringReader(exp))); SyntaxTree tree = parser.ParseExpression(); - Assert.AreEqual("Multiplication(UnaryMinus(Identifier(x)),UnaryMinus(Identifier(y)))", tree.ToString()); + ClassicAssert.AreEqual("Multiplication(UnaryMinus(Identifier(x)),UnaryMinus(Identifier(y)))", tree.ToString()); } [Test] @@ -68,7 +69,7 @@ public void TestUnaryAndNegativePower() { string exp = "-x^-y"; Parser parser = new Parser(new Scanner(new StringReader(exp))); SyntaxTree tree = parser.ParseExpression(); - Assert.AreEqual("UnaryMinus(Power(Identifier(x),UnaryMinus(Identifier(y))))", tree.ToString()); + ClassicAssert.AreEqual("UnaryMinus(Power(Identifier(x),UnaryMinus(Identifier(y))))", tree.ToString()); } [Test] @@ -76,7 +77,7 @@ public void TestUnaryAndNegativePowerTower() { string exp = "-x^-y^-z"; Parser parser = new Parser(new Scanner(new StringReader(exp))); SyntaxTree tree = parser.ParseExpression(); - Assert.AreEqual("UnaryMinus(Power(Identifier(x),UnaryMinus(Power(Identifier(y),UnaryMinus(Identifier(z))))))", tree.ToString()); + ClassicAssert.AreEqual("UnaryMinus(Power(Identifier(x),UnaryMinus(Power(Identifier(y),UnaryMinus(Identifier(z))))))", tree.ToString()); } [Test] @@ -84,7 +85,7 @@ public void TestMultiplicationDivision() { string exp = "x*y/z"; Parser parser = new Parser(new Scanner(new StringReader(exp))); SyntaxTree tree = parser.ParseExpression(); - Assert.AreEqual("Multiplication(Identifier(x),Division(Identifier(y),Identifier(z)))", tree.ToString()); + ClassicAssert.AreEqual("Multiplication(Identifier(x),Division(Identifier(y),Identifier(z)))", tree.ToString()); } [Test] @@ -92,7 +93,7 @@ public void TestDivisionDivision() { string exp = "x/y/z"; Parser parser = new Parser(new Scanner(new StringReader(exp))); SyntaxTree tree = parser.ParseExpression(); - Assert.AreEqual("Division(Division(Identifier(x),Identifier(y)),Identifier(z))", tree.ToString()); + ClassicAssert.AreEqual("Division(Division(Identifier(x),Identifier(y)),Identifier(z))", tree.ToString()); } [Test] @@ -100,7 +101,7 @@ public void TestDivisionMultiplication() { string exp = "x/y*z"; Parser parser = new Parser(new Scanner(new StringReader(exp))); SyntaxTree tree = parser.ParseExpression(); - Assert.AreEqual("Multiplication(Division(Identifier(x),Identifier(y)),Identifier(z))", tree.ToString()); + ClassicAssert.AreEqual("Multiplication(Division(Identifier(x),Identifier(y)),Identifier(z))", tree.ToString()); } [Test] @@ -108,7 +109,7 @@ public void TestAdditionSub() { string exp = "x+y-z"; Parser parser = new Parser(new Scanner(new StringReader(exp))); SyntaxTree tree = parser.ParseExpression(); - Assert.AreEqual("Subtraction(Addition(Identifier(x),Identifier(y)),Identifier(z))", tree.ToString()); + ClassicAssert.AreEqual("Subtraction(Addition(Identifier(x),Identifier(y)),Identifier(z))", tree.ToString()); } } diff --git a/tests/Hydrogen.NET.Tests/Math/MathCompilerScannerTests.cs b/tests/Hydrogen.NET.Tests/Math/MathCompilerScannerTests.cs index b0ec68317..e7893a335 100644 --- a/tests/Hydrogen.NET.Tests/Math/MathCompilerScannerTests.cs +++ b/tests/Hydrogen.NET.Tests/Math/MathCompilerScannerTests.cs @@ -9,6 +9,7 @@ using NUnit.Framework; using System.IO; using Hydrogen.Maths.Compiler; +using NUnit.Framework.Legacy; namespace Hydrogen.UnitTests; @@ -19,11 +20,11 @@ public class MathCompilerScannerTests { public void TestComplexTokenSequence() { string text = "ID1E-1E-3++"; Scanner scanner = new Scanner(new StringReader(text)); - Assert.AreEqual(TokenType.Identifier, scanner.GetNextToken().TokenType); - Assert.AreEqual(TokenType.Minus, scanner.GetNextToken().TokenType); - Assert.AreEqual(TokenType.Scalar, scanner.GetNextToken().TokenType); - Assert.AreEqual(TokenType.Plus, scanner.GetNextToken().TokenType); - Assert.AreEqual(TokenType.Plus, scanner.GetNextToken().TokenType); + ClassicAssert.AreEqual(TokenType.Identifier, scanner.GetNextToken().TokenType); + ClassicAssert.AreEqual(TokenType.Minus, scanner.GetNextToken().TokenType); + ClassicAssert.AreEqual(TokenType.Scalar, scanner.GetNextToken().TokenType); + ClassicAssert.AreEqual(TokenType.Plus, scanner.GetNextToken().TokenType); + ClassicAssert.AreEqual(TokenType.Plus, scanner.GetNextToken().TokenType); } @@ -32,9 +33,9 @@ public void TestNumber() { string text = "5"; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Scalar, token.TokenType); - Assert.AreEqual(5.ToString(), token.Value); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Scalar, token.TokenType); + ClassicAssert.AreEqual(5.ToString(), token.Value); } [Test] @@ -42,9 +43,9 @@ public void TestDecimal() { string text = "123.456"; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Scalar, token.TokenType); - Assert.AreEqual((123.456).ToString(), token.Value); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Scalar, token.TokenType); + ClassicAssert.AreEqual((123.456).ToString(), token.Value); } [Test] @@ -52,9 +53,9 @@ public void TestReal() { string text = "123.456E12"; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Scalar, token.TokenType); - Assert.AreEqual(double.Parse(text), double.Parse(token.Value)); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Scalar, token.TokenType); + ClassicAssert.AreEqual(double.Parse(text), double.Parse(token.Value)); } [Test] @@ -62,9 +63,9 @@ public void TestRealWithSign() { string text = " 123.456E-12 e"; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Scalar, token.TokenType); - Assert.AreEqual(double.Parse("123.456E-12"), double.Parse(token.Value)); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Scalar, token.TokenType); + ClassicAssert.AreEqual(double.Parse("123.456E-12"), double.Parse(token.Value)); } [Test] @@ -72,9 +73,9 @@ public void TestIdentifier() { string text = "abc123 "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Identifier, token.TokenType); - Assert.AreEqual("abc123", token.Value); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Identifier, token.TokenType); + ClassicAssert.AreEqual("abc123", token.Value); } @@ -83,8 +84,8 @@ public void TestPlus() { string text = " + "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Plus, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Plus, token.TokenType); } [Test] @@ -92,8 +93,8 @@ public void TestMinus() { string text = " - "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Minus, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Minus, token.TokenType); } [Test] @@ -101,8 +102,8 @@ public void TestMultiply() { string text = " * "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Multiply, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Multiply, token.TokenType); } @@ -111,8 +112,8 @@ public void TestDivide() { string text = " / "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Divide, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Divide, token.TokenType); } @@ -121,8 +122,8 @@ public void TestPower() { string text = " ^ "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Power, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Power, token.TokenType); } @@ -131,8 +132,8 @@ public void TestAssignment() { string text = " = "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Assignment, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Assignment, token.TokenType); } [Test] @@ -140,8 +141,8 @@ public void TestEquality() { string text = " == "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Equality, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Equality, token.TokenType); } [Test] @@ -149,8 +150,8 @@ public void TestAnd() { string text = " && "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.And, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.And, token.TokenType); } [Test] @@ -158,8 +159,8 @@ public void TestOr() { string text = " || "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Or, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Or, token.TokenType); } [Test] @@ -167,8 +168,8 @@ public void TestOpenBracket() { string text = " [ "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.OpenBracket, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.OpenBracket, token.TokenType); } [Test] @@ -176,8 +177,8 @@ public void TestCloseBracket() { string text = " ] "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.CloseBracket, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.CloseBracket, token.TokenType); } @@ -186,8 +187,8 @@ public void TestOpenParenthesis() { string text = " ( "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.OpenParenthesis, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.OpenParenthesis, token.TokenType); } [Test] @@ -195,8 +196,8 @@ public void TestCloseParenthesis() { string text = " ) "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.CloseParenthesis, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.CloseParenthesis, token.TokenType); } [Test] @@ -204,8 +205,8 @@ public void TestBeginBracket() { string text = " { "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.BeginBracket, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.BeginBracket, token.TokenType); } [Test] @@ -213,8 +214,8 @@ public void TestEndBracket() { string text = " } "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.EndBracket, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.EndBracket, token.TokenType); } [Test] @@ -222,8 +223,8 @@ public void TestComma() { string text = " , "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Comma, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Comma, token.TokenType); } [Test] @@ -231,8 +232,8 @@ public void TestDot() { string text = " . "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Dot, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Dot, token.TokenType); } [Test] @@ -240,8 +241,8 @@ public void TestLet() { string text = " leT "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Let, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Let, token.TokenType); } [Test] @@ -249,8 +250,8 @@ public void TestIf() { string text = " If "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.If, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.If, token.TokenType); } [Test] @@ -258,8 +259,8 @@ public void TestThen() { string text = " tHeN "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Then, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Then, token.TokenType); } @@ -268,8 +269,8 @@ public void TestElse() { string text = " else "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Else, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Else, token.TokenType); } @@ -278,8 +279,8 @@ public void TestSemiColon() { string text = " ; "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.SemiColon, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.SemiColon, token.TokenType); } @@ -288,8 +289,8 @@ public void TestNot() { string text = " ! "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Not, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Not, token.TokenType); } @@ -298,8 +299,8 @@ public void TestInequality() { string text = " != "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Inequality, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Inequality, token.TokenType); } @@ -308,8 +309,8 @@ public void TestModulus() { string text = " % "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.Modulus, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.Modulus, token.TokenType); } [Test] @@ -317,8 +318,8 @@ public void TestLessThan() { string text = " < "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.LessThan, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.LessThan, token.TokenType); } [Test] @@ -326,8 +327,8 @@ public void TesLessThanEqualTo() { string text = " <= "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.LessThanEqualTo, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.LessThanEqualTo, token.TokenType); } [Test] @@ -335,8 +336,8 @@ public void TestGreaterThan() { string text = " > "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.GreaterThan, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.GreaterThan, token.TokenType); } @@ -345,8 +346,8 @@ public void TestGreaterThanEqualTo() { string text = " >= "; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.GreaterThanEqualTo, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.GreaterThanEqualTo, token.TokenType); } @@ -355,7 +356,7 @@ public void TestEndOfCode() { string text = ""; Scanner scanner = new Scanner(new StringReader(text)); Token token = scanner.GetNextToken(); - Assert.IsNotNull(token); - Assert.AreEqual(TokenType.EndOfCode, token.TokenType); + ClassicAssert.IsNotNull(token); + ClassicAssert.AreEqual(TokenType.EndOfCode, token.TokenType); } } diff --git a/tests/Hydrogen.Tests/Cache/CacheTests.cs b/tests/Hydrogen.Tests/Cache/CacheTests.cs index 9e84320d4..24177074f 100644 --- a/tests/Hydrogen.Tests/Cache/CacheTests.cs +++ b/tests/Hydrogen.Tests/Cache/CacheTests.cs @@ -11,6 +11,7 @@ using System.Collections.Generic; using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -38,9 +39,9 @@ void Handler(int arg1, int arg2) { public void MaxCapacity_1() { var cache = new ActionCache(x => x, sizeEstimator: x => 1, maxCapacity: 1, reapStrategy: CacheReapPolicy.LeastUsed); var val = cache[0]; - Assert.AreEqual(1, cache.ItemCount); + ClassicAssert.AreEqual(1, cache.ItemCount); val = cache[1]; - Assert.AreEqual(1, cache.ItemCount); + ClassicAssert.AreEqual(1, cache.ItemCount); } [Test] @@ -49,10 +50,10 @@ public void MaxCapacity_2() { var val = cache[0]; val = cache[1]; val = cache[2]; - Assert.AreEqual(3, cache.ItemCount); + ClassicAssert.AreEqual(3, cache.ItemCount); for (var i = 3; i < 1000; i++) { val = cache[i]; - Assert.AreEqual(3, cache.ItemCount); + ClassicAssert.AreEqual(3, cache.ItemCount); } } @@ -64,11 +65,11 @@ public void ItemRemoved_1() { cache.ItemRemoved += (i, item) => removed.Add(item.Value); var val = cache[0]; - Assert.AreEqual(0, removed.Count); + ClassicAssert.AreEqual(0, removed.Count); val = cache[1]; - Assert.AreEqual(1, removed.Count); - Assert.AreEqual(0, removed[0]); + ClassicAssert.AreEqual(1, removed.Count); + ClassicAssert.AreEqual(0, removed[0]); } [Test] @@ -81,9 +82,9 @@ public void ItemRemoved_2() { var val = cache[i]; } - Assert.AreEqual(999, removed.Count); + ClassicAssert.AreEqual(999, removed.Count); removed.Sort(); - Assert.AreEqual(Enumerable.Range(0, 999).ToArray(), removed.ToArray()); + ClassicAssert.AreEqual(Enumerable.Range(0, 999).ToArray(), removed.ToArray()); } [Test] @@ -92,8 +93,8 @@ public void BulkTest_Simple_1() { () => new Dictionary() { { 1, "one" }, { 2, "two" }, { 3, "three" } }); - Assert.AreEqual("one", cache[1]); - Assert.AreEqual(new[] { "one", "two", "three" }, cache.CachedItems.Select(x => x.Value).ToArray()); + ClassicAssert.AreEqual("one", cache[1]); + ClassicAssert.AreEqual(new[] { "one", "two", "three" }, cache.CachedItems.Select(x => x.Value).ToArray()); } [Test] @@ -105,14 +106,14 @@ public void ExpirationTest_Simple_1() { expirationStrategy: ExpirationPolicy.SinceFetchedTime, expirationDuration: TimeSpan.FromMilliseconds(100) ); - Assert.AreEqual("first", cache[1]); + ClassicAssert.AreEqual("first", cache[1]); val = "second"; - Assert.AreEqual("first", cache[1]); - Assert.AreEqual("first", cache[1]); + ClassicAssert.AreEqual("first", cache[1]); + ClassicAssert.AreEqual("first", cache[1]); Thread.Sleep(111); - Assert.AreEqual("second", cache[1]); - Assert.AreEqual("second", cache[1]); - Assert.AreEqual("second", cache[1]); + ClassicAssert.AreEqual("second", cache[1]); + ClassicAssert.AreEqual("second", cache[1]); + ClassicAssert.AreEqual("second", cache[1]); } [Test] @@ -129,15 +130,15 @@ public void SizeTest_Simple_1() { Assert.Throws(() => { var x = cache[101]; }); - Assert.AreEqual("98", cache[98]); - Assert.AreEqual(1, cache.InternalStorage.Count); - Assert.AreEqual("2", cache[2]); - Assert.AreEqual(2, cache.InternalStorage.Count); - Assert.AreEqual("1", cache[1]); - Assert.AreEqual(2, cache.InternalStorage.Count); // should have purged first item - Assert.AreEqual(new[] { "1", "2" }, cache.GetAllCachedValues().ToArray()); - Assert.AreEqual("100", cache[100]); - Assert.AreEqual(1, cache.InternalStorage.Count); // should have purged everything + ClassicAssert.AreEqual("98", cache[98]); + ClassicAssert.AreEqual(1, cache.InternalStorage.Count); + ClassicAssert.AreEqual("2", cache[2]); + ClassicAssert.AreEqual(2, cache.InternalStorage.Count); + ClassicAssert.AreEqual("1", cache[1]); + ClassicAssert.AreEqual(2, cache.InternalStorage.Count); // should have purged first item + ClassicAssert.AreEqual(new[] { "1", "2" }, cache.GetAllCachedValues().ToArray()); + ClassicAssert.AreEqual("100", cache[100]); + ClassicAssert.AreEqual(1, cache.InternalStorage.Count); // should have purged everything } [Test] @@ -156,11 +157,11 @@ public void ContainsCachedItem_1() { expirationStrategy: ExpirationPolicy.SinceFetchedTime, expirationDuration: TimeSpan.FromMilliseconds(100) ); - Assert.IsFalse(cache.ContainsCachedItem(1)); + ClassicAssert.IsFalse(cache.ContainsCachedItem(1)); var val = cache[1]; - Assert.IsTrue(cache.ContainsCachedItem(1)); + ClassicAssert.IsTrue(cache.ContainsCachedItem(1)); Thread.Sleep(111); - Assert.IsFalse(cache.ContainsCachedItem(1)); + ClassicAssert.IsFalse(cache.ContainsCachedItem(1)); } @@ -173,8 +174,8 @@ public void TestEmptySize() { ); for (var i = 0; i < 100; i++) { var item = cache[i]; - Assert.AreEqual(i + 1, cache.ItemCount); - Assert.AreEqual(0, cache.CurrentSize); + ClassicAssert.AreEqual(i + 1, cache.ItemCount); + ClassicAssert.AreEqual(0, cache.CurrentSize); } } diff --git a/tests/Hydrogen.Tests/Cache/PooledCacheTests.cs b/tests/Hydrogen.Tests/Cache/PooledCacheTests.cs index 40e228d25..a3b23509d 100644 --- a/tests/Hydrogen.Tests/Cache/PooledCacheTests.cs +++ b/tests/Hydrogen.Tests/Cache/PooledCacheTests.cs @@ -11,6 +11,7 @@ using System.Linq; using System.Threading.Tasks; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -35,8 +36,8 @@ public void Exhausted_RequestdSpaceTooLarge() { var _1 = cache1.Get(9); // allocated 9 bytes, total 9 var _2 = cache2.Get("0"); // allocated 1 bytes, total 10 (pool exhausted now) Assert.Throws(() => cache1.Get(11)); // allocated 11 bytes, too much - Assert.IsFalse(_1.Traits.HasFlag(CachedItemTraits.Purged)); - Assert.IsFalse(_2.Traits.HasFlag(CachedItemTraits.Purged)); + ClassicAssert.IsFalse(_1.Traits.HasFlag(CachedItemTraits.Purged)); + ClassicAssert.IsFalse(_2.Traits.HasFlag(CachedItemTraits.Purged)); } [Test] @@ -49,8 +50,8 @@ public void Exhausted_NotEnoughSpaceDueToUnpurgable() { var _2 = cache2.Get("0"); // allocated 1 bytes, total 10 (pool exhausted now) _2.CanPurge = false; Assert.Throws(() => cache1.Get(10)); // allocated 10 bytes, but can't purge _2 - Assert.IsTrue(_1.Traits.HasFlag(CachedItemTraits.Purged)); // purged this one whilst trying to free space - Assert.IsFalse(_2.Traits.HasFlag(CachedItemTraits.Purged)); // didn't purge this one, then failed and threw + ClassicAssert.IsTrue(_1.Traits.HasFlag(CachedItemTraits.Purged)); // purged this one whilst trying to free space + ClassicAssert.IsFalse(_2.Traits.HasFlag(CachedItemTraits.Purged)); // didn't purge this one, then failed and threw } [Test] @@ -60,22 +61,22 @@ public void Simple_1() { using var cache2 = new ActionCache(x => x, sizeEstimator: x => x.Length, maxCapacity: 10, reapStrategy: CacheReapPolicy.Smallest, reaper: pool); var _1 = cache1.Get(9); // allocated 9 bytes, total 9 - Assert.AreEqual(9, cache1.CurrentSize); - Assert.AreEqual(9, pool.CurrentSize); + ClassicAssert.AreEqual(9, cache1.CurrentSize); + ClassicAssert.AreEqual(9, pool.CurrentSize); var _2 = cache2.Get("0"); // allocated 1 bytes, total 10 (pool full now) - Assert.AreEqual(9, cache1.CurrentSize); - Assert.AreEqual(1, cache2.CurrentSize); - Assert.AreEqual(10, pool.CurrentSize); + ClassicAssert.AreEqual(9, cache1.CurrentSize); + ClassicAssert.AreEqual(1, cache2.CurrentSize); + ClassicAssert.AreEqual(10, pool.CurrentSize); var _3 = cache1.Get(1); // allocated 1 bytes, will reap _1 but not _2 - Assert.AreEqual(1, cache1.CurrentSize); - Assert.AreEqual(1, cache2.CurrentSize); - Assert.AreEqual(2, pool.CurrentSize); + ClassicAssert.AreEqual(1, cache1.CurrentSize); + ClassicAssert.AreEqual(1, cache2.CurrentSize); + ClassicAssert.AreEqual(2, pool.CurrentSize); - Assert.IsTrue(_1.Traits.HasFlag(CachedItemTraits.Purged)); - Assert.IsFalse(_2.Traits.HasFlag(CachedItemTraits.Purged)); - Assert.IsFalse(_3.Traits.HasFlag(CachedItemTraits.Purged)); + ClassicAssert.IsTrue(_1.Traits.HasFlag(CachedItemTraits.Purged)); + ClassicAssert.IsFalse(_2.Traits.HasFlag(CachedItemTraits.Purged)); + ClassicAssert.IsFalse(_3.Traits.HasFlag(CachedItemTraits.Purged)); } [Test] @@ -85,23 +86,23 @@ public void Simple_2() { using var cache2 = new ActionCache(x => x, sizeEstimator: x => x.Length, maxCapacity: 10, reapStrategy: CacheReapPolicy.Smallest, reaper: pool); var _1 = cache1.Get(9); // allocated 9 bytes, total 9 - Assert.AreEqual(9, cache1.CurrentSize); - Assert.AreEqual(0, cache2.CurrentSize); - Assert.AreEqual(9, pool.CurrentSize); + ClassicAssert.AreEqual(9, cache1.CurrentSize); + ClassicAssert.AreEqual(0, cache2.CurrentSize); + ClassicAssert.AreEqual(9, pool.CurrentSize); var _2 = cache2.Get("0"); // allocated 1 bytes, total 10 (pool full now) - Assert.AreEqual(9, cache1.CurrentSize); - Assert.AreEqual(1, cache2.CurrentSize); - Assert.AreEqual(10, pool.CurrentSize); + ClassicAssert.AreEqual(9, cache1.CurrentSize); + ClassicAssert.AreEqual(1, cache2.CurrentSize); + ClassicAssert.AreEqual(10, pool.CurrentSize); var _3 = cache1.Get(10); // allocated 10 bytes, needs to reap _1 and _2 - Assert.AreEqual(10, cache1.CurrentSize); - Assert.AreEqual(0, cache2.CurrentSize); - Assert.AreEqual(10, pool.CurrentSize); + ClassicAssert.AreEqual(10, cache1.CurrentSize); + ClassicAssert.AreEqual(0, cache2.CurrentSize); + ClassicAssert.AreEqual(10, pool.CurrentSize); - Assert.IsTrue(_1.Traits.HasFlag(CachedItemTraits.Purged)); - Assert.IsTrue(_2.Traits.HasFlag(CachedItemTraits.Purged)); - Assert.IsFalse(_3.Traits.HasFlag(CachedItemTraits.Purged)); + ClassicAssert.IsTrue(_1.Traits.HasFlag(CachedItemTraits.Purged)); + ClassicAssert.IsTrue(_2.Traits.HasFlag(CachedItemTraits.Purged)); + ClassicAssert.IsFalse(_3.Traits.HasFlag(CachedItemTraits.Purged)); } [Test] @@ -124,7 +125,7 @@ public void Integration([Values(10, 100)] int numCaches, [Values(100, 1000, 1000 Task.WaitAll(tasks); - Assert.LessOrEqual(maxSizeEver, maxCapacity); + ClassicAssert.LessOrEqual(maxSizeEver, maxCapacity); System.Console.WriteLine($"Max Size Reached: {maxSizeEver}, Total Removes: {removes}, Max Item Count Reached: {maxItemCountEver}"); void CacheLoop(ICache c, int index) { diff --git a/tests/Hydrogen.Tests/Cache/SessionCacheTests.cs b/tests/Hydrogen.Tests/Cache/SessionCacheTests.cs index b629d1676..ab25afe10 100644 --- a/tests/Hydrogen.Tests/Cache/SessionCacheTests.cs +++ b/tests/Hydrogen.Tests/Cache/SessionCacheTests.cs @@ -9,6 +9,7 @@ using System; using System.Threading; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -22,7 +23,7 @@ public void Simple_1() { cache.Set(1, "one"); Thread.Sleep(300); cache.Cleanup(); // Need to call this manually since https://dzone.com/articles/unit-testing-multi-threaded - Assert.AreEqual(0, cache.ItemCount); + ClassicAssert.AreEqual(0, cache.ItemCount); } [Test] @@ -34,10 +35,10 @@ public void Simple_2() { cache.Set(4, "four"); cache.Set(5, "five"); cache.Set(6, "six"); - Assert.AreEqual(6, cache.ItemCount); + ClassicAssert.AreEqual(6, cache.ItemCount); Thread.Sleep(300); cache.Cleanup(); // Need to call this manually since https://dzone.com/articles/unit-testing-multi-threaded - Assert.AreEqual(0, cache.ItemCount); + ClassicAssert.AreEqual(0, cache.ItemCount); } @@ -50,7 +51,7 @@ public void Complex_1() { cache.Set(4, "four"); cache.Set(5, "five"); cache.Set(6, "six"); - Assert.AreEqual(6, cache.ItemCount); + ClassicAssert.AreEqual(6, cache.ItemCount); for (var i = 0; i < 10; i++) { cache.KeepAlive(1); cache.KeepAlive(2); @@ -59,10 +60,10 @@ public void Complex_1() { } cache.Cleanup(); // Need to call this manually since https://dzone.com/articles/unit-testing-multi-threaded var remaining = cache.InternalStorage; - Assert.AreEqual(3, remaining.Count); - Assert.IsTrue(remaining.ContainsKey(1)); - Assert.IsTrue(remaining.ContainsKey(2)); - Assert.IsTrue(remaining.ContainsKey(3)); + ClassicAssert.AreEqual(3, remaining.Count); + ClassicAssert.IsTrue(remaining.ContainsKey(1)); + ClassicAssert.IsTrue(remaining.ContainsKey(2)); + ClassicAssert.IsTrue(remaining.ContainsKey(3)); } [Test] @@ -74,7 +75,7 @@ public void Complex_2() { cache.Set(4, "four"); cache.Set(5, "five"); cache.Set(6, "six"); - Assert.AreEqual(6, cache.ItemCount); + ClassicAssert.AreEqual(6, cache.ItemCount); for (int i = 0; i < 6; i++) { Thread.Sleep(100); cache.KeepAlive(1); @@ -85,8 +86,8 @@ public void Complex_2() { cache.Remove(3); cache.Cleanup(); // Need to call this manually since https://dzone.com/articles/unit-testing-multi-threaded var remaining = cache.InternalStorage; - Assert.AreEqual(1, remaining.Count); - Assert.IsTrue(remaining.ContainsKey(1)); + ClassicAssert.AreEqual(1, remaining.Count); + ClassicAssert.IsTrue(remaining.ContainsKey(1)); } @@ -98,7 +99,7 @@ public void SessionDisposed() { cache.Set(1, Tools.Scope.ExecuteOnDispose(() => disposed = true)); Thread.Sleep(200); cache.Cleanup(); // Need to call this manually since https://dzone.com/articles/unit-testing-multi-threaded - Assert.IsTrue(disposed); + ClassicAssert.IsTrue(disposed); } [Test] @@ -108,7 +109,7 @@ public void SessionDisposedOnFlush() { cache.ItemRemoved += (i, item) => item.Dispose(); cache.Set(1, Tools.Scope.ExecuteOnDispose(() => disposed = true)); cache.Purge(); - Assert.IsTrue(disposed); + ClassicAssert.IsTrue(disposed); } @@ -116,7 +117,7 @@ public void SessionDisposedOnFlush() { public void Throws_1() { var cache = new SessionCache(TimeSpan.FromMilliseconds(100)); cache.Set(1, "one"); - Assert.AreEqual("one", cache[1]); + ClassicAssert.AreEqual("one", cache[1]); Thread.Sleep(300); Assert.Throws(() => { var x = cache[1]; @@ -130,10 +131,10 @@ public void DoesNotExpire() { cache.Set(1, "one"); DateTime start = DateTime.Now; while (DateTime.Now.Subtract(start).TotalSeconds <= 1.0D) { - Assert.AreEqual("one", cache[1]); + ClassicAssert.AreEqual("one", cache[1]); Thread.Sleep(50); } - Assert.AreEqual("one", cache[1]); + ClassicAssert.AreEqual("one", cache[1]); } diff --git a/tests/Hydrogen.Tests/Collections/Buffer/BufferTests.cs b/tests/Hydrogen.Tests/Collections/Buffer/BufferTests.cs index ab0a4a1bf..7884420d4 100644 --- a/tests/Hydrogen.Tests/Collections/Buffer/BufferTests.cs +++ b/tests/Hydrogen.Tests/Collections/Buffer/BufferTests.cs @@ -13,6 +13,7 @@ using System.IO; using Hydrogen.Collections; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -28,18 +29,18 @@ public void SinglePage( using (CreateMemPagedBuffer(storageType, pageSize, maxOpenPages * (long)pageSize, out var buffer)) { buffer.AddRange(Tools.Array.Gen(pageSize, 10)); // Check page - Assert.AreEqual(1, buffer.Pages.Count()); - Assert.AreEqual(0, buffer.Pages[0].Number); - Assert.AreEqual(pageSize, buffer.Pages[0].MaxSize); - Assert.AreEqual(0, buffer.Pages[0].StartIndex); - Assert.AreEqual(pageSize, buffer.Pages[0].Count); - Assert.AreEqual(pageSize - 1, buffer.Pages[0].EndIndex); - Assert.AreEqual(pageSize, buffer.Pages[0].Size); - Assert.IsTrue(buffer.Pages[0].Dirty); + ClassicAssert.AreEqual(1, buffer.Pages.Count()); + ClassicAssert.AreEqual(0, buffer.Pages[0].Number); + ClassicAssert.AreEqual(pageSize, buffer.Pages[0].MaxSize); + ClassicAssert.AreEqual(0, buffer.Pages[0].StartIndex); + ClassicAssert.AreEqual(pageSize, buffer.Pages[0].Count); + ClassicAssert.AreEqual(pageSize - 1, buffer.Pages[0].EndIndex); + ClassicAssert.AreEqual(pageSize, buffer.Pages[0].Size); + ClassicAssert.IsTrue(buffer.Pages[0].Dirty); // Check value - Assert.AreEqual(10, buffer[0]); - Assert.AreEqual(pageSize, buffer.Count); + ClassicAssert.AreEqual(10, buffer[0]); + ClassicAssert.AreEqual(pageSize, buffer.Count); } } @@ -54,42 +55,42 @@ public void TwoPages( buffer.AddRange(Tools.Array.Gen(pageSize, 10)); // Check Page 1 - Assert.AreEqual(1, buffer.Pages.Count()); - Assert.AreEqual(PageState.Loaded, buffer.Pages[0].State); - Assert.AreEqual(0, buffer.Pages[0].Number); - Assert.AreEqual(pageSize, buffer.Pages[0].MaxSize); - Assert.AreEqual(0, buffer.Pages[0].StartIndex); - Assert.AreEqual(pageSize, buffer.Pages[0].Count); - Assert.AreEqual(pageSize - 1, buffer.Pages[0].EndIndex); - Assert.AreEqual(pageSize, buffer.Pages[0].Size); - Assert.IsTrue(buffer.Pages[0].Dirty); + ClassicAssert.AreEqual(1, buffer.Pages.Count()); + ClassicAssert.AreEqual(PageState.Loaded, buffer.Pages[0].State); + ClassicAssert.AreEqual(0, buffer.Pages[0].Number); + ClassicAssert.AreEqual(pageSize, buffer.Pages[0].MaxSize); + ClassicAssert.AreEqual(0, buffer.Pages[0].StartIndex); + ClassicAssert.AreEqual(pageSize, buffer.Pages[0].Count); + ClassicAssert.AreEqual(pageSize - 1, buffer.Pages[0].EndIndex); + ClassicAssert.AreEqual(pageSize, buffer.Pages[0].Size); + ClassicAssert.IsTrue(buffer.Pages[0].Dirty); // Add new page buffer.AddRange(Tools.Array.Gen(pageSize, 20)); // Check pages 1 & 2 - Assert.AreEqual(2, buffer.Pages.Count()); - Assert.AreEqual(PageState.Unloaded, buffer.Pages[0].State); - Assert.AreEqual(0, buffer.Pages[0].Number); - Assert.AreEqual(pageSize, buffer.Pages[0].MaxSize); - Assert.AreEqual(0, buffer.Pages[0].StartIndex); - Assert.AreEqual(pageSize, buffer.Pages[0].Count); - Assert.AreEqual(pageSize - 1, buffer.Pages[0].EndIndex); - Assert.AreEqual(pageSize, buffer.Pages[0].Size); - - - Assert.AreEqual(PageState.Loaded, buffer.Pages[1].State); - Assert.AreEqual(1, buffer.Pages[1].Number); - Assert.AreEqual(pageSize, buffer.Pages[1].MaxSize); - Assert.AreEqual(pageSize, buffer.Pages[1].StartIndex); - Assert.AreEqual(pageSize, buffer.Pages[1].Count); - Assert.AreEqual(pageSize * 2 - 1, buffer.Pages[1].EndIndex); - Assert.AreEqual(pageSize, buffer.Pages[1].Size); - Assert.IsTrue(buffer.Pages[1].Dirty); + ClassicAssert.AreEqual(2, buffer.Pages.Count()); + ClassicAssert.AreEqual(PageState.Unloaded, buffer.Pages[0].State); + ClassicAssert.AreEqual(0, buffer.Pages[0].Number); + ClassicAssert.AreEqual(pageSize, buffer.Pages[0].MaxSize); + ClassicAssert.AreEqual(0, buffer.Pages[0].StartIndex); + ClassicAssert.AreEqual(pageSize, buffer.Pages[0].Count); + ClassicAssert.AreEqual(pageSize - 1, buffer.Pages[0].EndIndex); + ClassicAssert.AreEqual(pageSize, buffer.Pages[0].Size); + + + ClassicAssert.AreEqual(PageState.Loaded, buffer.Pages[1].State); + ClassicAssert.AreEqual(1, buffer.Pages[1].Number); + ClassicAssert.AreEqual(pageSize, buffer.Pages[1].MaxSize); + ClassicAssert.AreEqual(pageSize, buffer.Pages[1].StartIndex); + ClassicAssert.AreEqual(pageSize, buffer.Pages[1].Count); + ClassicAssert.AreEqual(pageSize * 2 - 1, buffer.Pages[1].EndIndex); + ClassicAssert.AreEqual(pageSize, buffer.Pages[1].Size); + ClassicAssert.IsTrue(buffer.Pages[1].Dirty); // Check values - Assert.AreEqual(10, buffer[0]); - Assert.AreEqual(20, buffer[pageSize]); + ClassicAssert.AreEqual(10, buffer[0]); + ClassicAssert.AreEqual(20, buffer[pageSize]); } } @@ -103,9 +104,9 @@ public void RemoveAll( using (CreateMemPagedBuffer(storageType, pageSize, maxOpenPages * (long)pageSize, out var buffer)) { buffer.AddRange(Tools.Array.Gen(pageSize, 10)); buffer.RemoveRange(0, buffer.Count); - Assert.AreEqual(0, buffer.Pages.Count); - Assert.AreEqual(0, buffer.Count); - Assert.AreEqual(Enumerable.Empty(), buffer); + ClassicAssert.AreEqual(0, buffer.Pages.Count); + ClassicAssert.AreEqual(0, buffer.Count); + ClassicAssert.AreEqual(Enumerable.Empty(), buffer); } } @@ -118,9 +119,9 @@ public void RemoveAllExcept1( using (CreateMemPagedBuffer(storageType, pageSize, maxOpenPages * (long)pageSize, out var buffer)) { buffer.AddRange(Tools.Array.Gen(pageSize, 10)); buffer.RemoveRange(1, buffer.Count - 1); - Assert.AreEqual(1, buffer.Pages.Count); - Assert.AreEqual(1, buffer.Count); - Assert.AreEqual(new byte[] { 10 }, buffer); + ClassicAssert.AreEqual(1, buffer.Pages.Count); + ClassicAssert.AreEqual(1, buffer.Count); + ClassicAssert.AreEqual(new byte[] { 10 }, buffer); } } @@ -134,15 +135,15 @@ public void Rewind( using (CreateMemPagedBuffer(storageType, pageSize, maxOpenPages * (long)pageSize, out var buffer)) { buffer.AddRange(127, 16, 15, 14, 13); buffer.RemoveRange(1, 4); - Assert.AreEqual(1, buffer.Count); - Assert.AreEqual(127, buffer[0]); + ClassicAssert.AreEqual(1, buffer.Count); + ClassicAssert.AreEqual(127, buffer[0]); buffer.AddRange(17, 18, 19); - Assert.AreEqual(4, buffer.Count); - Assert.AreEqual(127, buffer[0]); - Assert.AreEqual(17, buffer[1]); - Assert.AreEqual(18, buffer[2]); - Assert.AreEqual(19, buffer[3]); - Assert.AreEqual(expected, buffer); + ClassicAssert.AreEqual(4, buffer.Count); + ClassicAssert.AreEqual(127, buffer[0]); + ClassicAssert.AreEqual(17, buffer[1]); + ClassicAssert.AreEqual(18, buffer[2]); + ClassicAssert.AreEqual(19, buffer[3]); + ClassicAssert.AreEqual(expected, buffer); } } diff --git a/tests/Hydrogen.Tests/Collections/Buffer/FileMappedBufferTests.cs b/tests/Hydrogen.Tests/Collections/Buffer/FileMappedBufferTests.cs index 066149b50..15861ca11 100644 --- a/tests/Hydrogen.Tests/Collections/Buffer/FileMappedBufferTests.cs +++ b/tests/Hydrogen.Tests/Collections/Buffer/FileMappedBufferTests.cs @@ -12,6 +12,7 @@ using NUnit.Framework; using System.IO; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -26,18 +27,18 @@ public void SingleByteFile_Save() { using (Tools.Scope.ExecuteOnDispose(() => File.Delete(fileName))) { using (var binaryFile = new FileMappedBuffer(PagedFileDescriptor.From( fileName, 1, 1))) { - Assert.AreEqual(0, binaryFile.Pages.Count()); + ClassicAssert.AreEqual(0, binaryFile.Pages.Count()); binaryFile.AddRange(expected); // Check page - Assert.AreEqual(1, binaryFile.Pages.Count()); - Assert.AreEqual(0, binaryFile.Pages[0].StartIndex); - Assert.AreEqual(1, binaryFile.Pages[0].Count); - Assert.AreEqual(0, binaryFile.Pages[0].EndIndex); - Assert.IsTrue(binaryFile.Pages[0].Dirty); + ClassicAssert.AreEqual(1, binaryFile.Pages.Count()); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].StartIndex); + ClassicAssert.AreEqual(1, binaryFile.Pages[0].Count); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].EndIndex); + ClassicAssert.IsTrue(binaryFile.Pages[0].Dirty); } // Check saved - Assert.AreEqual(expected, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(expected, File.ReadAllBytes(fileName)); } } @@ -50,19 +51,19 @@ public void SingleByteFile_Load() { using (var binaryFile = new FileMappedBuffer(PagedFileDescriptor.From( fileName, 1, 1), FileAccessMode.Read | FileAccessMode.AutoLoad)) { // Check page - Assert.AreEqual(1, binaryFile.Pages.Count()); - Assert.AreEqual(0, binaryFile.Pages[0].StartIndex); - Assert.AreEqual(1, binaryFile.Pages[0].Count); - Assert.AreEqual(0, binaryFile.Pages[0].EndIndex); - Assert.IsFalse(binaryFile.Pages[0].Dirty); + ClassicAssert.AreEqual(1, binaryFile.Pages.Count()); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].StartIndex); + ClassicAssert.AreEqual(1, binaryFile.Pages[0].Count); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].EndIndex); + ClassicAssert.IsFalse(binaryFile.Pages[0].Dirty); // Check value - Assert.AreEqual(expected, binaryFile); - Assert.AreEqual(1, binaryFile.Count); - Assert.AreEqual(1, binaryFile.CalculateTotalSize()); + ClassicAssert.AreEqual(expected, binaryFile); + ClassicAssert.AreEqual(1, binaryFile.Count); + ClassicAssert.AreEqual(1, binaryFile.CalculateTotalSize()); } // Check file unchanged - Assert.AreEqual(expected, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(expected, File.ReadAllBytes(fileName)); } } @@ -79,26 +80,26 @@ public void Grow() { binaryFile.AddRange(appendedBytes); // Check pages 1 & 2 - Assert.AreEqual(2, binaryFile.Pages.Count()); - Assert.IsTrue(binaryFile.Pages[0].State == PageState.Unloaded); - Assert.AreEqual(0, binaryFile.Pages[0].StartIndex); - Assert.AreEqual(1, binaryFile.Pages[0].Count); - Assert.AreEqual(0, binaryFile.Pages[0].EndIndex); - Assert.IsFalse(binaryFile.Pages[0].Dirty); - - Assert.IsTrue(binaryFile.Pages[1].State == PageState.Loaded); - Assert.AreEqual(1, binaryFile.Pages[1].StartIndex); - Assert.AreEqual(1, binaryFile.Pages[1].Count); - Assert.AreEqual(1, binaryFile.Pages[1].EndIndex); - Assert.IsTrue(binaryFile.Pages[1].Dirty); + ClassicAssert.AreEqual(2, binaryFile.Pages.Count()); + ClassicAssert.IsTrue(binaryFile.Pages[0].State == PageState.Unloaded); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].StartIndex); + ClassicAssert.AreEqual(1, binaryFile.Pages[0].Count); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].EndIndex); + ClassicAssert.IsFalse(binaryFile.Pages[0].Dirty); + + ClassicAssert.IsTrue(binaryFile.Pages[1].State == PageState.Loaded); + ClassicAssert.AreEqual(1, binaryFile.Pages[1].StartIndex); + ClassicAssert.AreEqual(1, binaryFile.Pages[1].Count); + ClassicAssert.AreEqual(1, binaryFile.Pages[1].EndIndex); + ClassicAssert.IsTrue(binaryFile.Pages[1].Dirty); // Check value - Assert.AreEqual(expected, binaryFile); - Assert.AreEqual(2, binaryFile.Count); - Assert.AreEqual(2, binaryFile.CalculateTotalSize()); + ClassicAssert.AreEqual(expected, binaryFile); + ClassicAssert.AreEqual(2, binaryFile.Count); + ClassicAssert.AreEqual(2, binaryFile.CalculateTotalSize()); } // Check file was saved appended - Assert.AreEqual(expected, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(expected, File.ReadAllBytes(fileName)); } } @@ -112,33 +113,33 @@ public void NibbleFile_Save() { binaryFile.Add(expected[0]); // Check Page 1 - Assert.AreEqual(1, binaryFile.Pages.Count()); - Assert.IsTrue(binaryFile.Pages[0].State == PageState.Loaded); - Assert.AreEqual(0, binaryFile.Pages[0].StartIndex); - Assert.AreEqual(1, binaryFile.Pages[0].Count); - Assert.AreEqual(0, binaryFile.Pages[0].EndIndex); - Assert.IsTrue(binaryFile.Pages[0].Dirty); + ClassicAssert.AreEqual(1, binaryFile.Pages.Count()); + ClassicAssert.IsTrue(binaryFile.Pages[0].State == PageState.Loaded); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].StartIndex); + ClassicAssert.AreEqual(1, binaryFile.Pages[0].Count); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].EndIndex); + ClassicAssert.IsTrue(binaryFile.Pages[0].Dirty); // Add new page binaryFile.Add(expected[1]); // Check pages 1 & 2 - Assert.AreEqual(2, binaryFile.Pages.Count()); - Assert.IsTrue(binaryFile.Pages[0].State == PageState.Unloaded); - Assert.AreEqual(0, binaryFile.Pages[0].StartIndex); - Assert.AreEqual(1, binaryFile.Pages[0].Count); - Assert.AreEqual(0, binaryFile.Pages[0].EndIndex); - Assert.IsFalse(binaryFile.Pages[0].Dirty); - - Assert.IsTrue(binaryFile.Pages[1].State == PageState.Loaded); - Assert.AreEqual(1, binaryFile.Pages[1].StartIndex); - Assert.AreEqual(1, binaryFile.Pages[1].Count); - Assert.AreEqual(1, binaryFile.Pages[1].EndIndex); - Assert.IsTrue(binaryFile.Pages[1].Dirty); + ClassicAssert.AreEqual(2, binaryFile.Pages.Count()); + ClassicAssert.IsTrue(binaryFile.Pages[0].State == PageState.Unloaded); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].StartIndex); + ClassicAssert.AreEqual(1, binaryFile.Pages[0].Count); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].EndIndex); + ClassicAssert.IsFalse(binaryFile.Pages[0].Dirty); + + ClassicAssert.IsTrue(binaryFile.Pages[1].State == PageState.Loaded); + ClassicAssert.AreEqual(1, binaryFile.Pages[1].StartIndex); + ClassicAssert.AreEqual(1, binaryFile.Pages[1].Count); + ClassicAssert.AreEqual(1, binaryFile.Pages[1].EndIndex); + ClassicAssert.IsTrue(binaryFile.Pages[1].Dirty); } // Check saved - Assert.AreEqual(expected, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(expected, File.ReadAllBytes(fileName)); } } @@ -151,14 +152,14 @@ public void Rewind() { binaryFile.AddRange(127, 16, 15, 14, 13); binaryFile.RemoveRange(1, 4); - Assert.AreEqual(1, binaryFile.Count); - Assert.AreEqual(127, binaryFile[0]); + ClassicAssert.AreEqual(1, binaryFile.Count); + ClassicAssert.AreEqual(127, binaryFile[0]); binaryFile.AddRange(17, 18, 19); - Assert.AreEqual(4, binaryFile.Count); - Assert.AreEqual(expected, binaryFile); + ClassicAssert.AreEqual(4, binaryFile.Count); + ClassicAssert.AreEqual(expected, binaryFile); } // Check saved - Assert.AreEqual(expected, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(expected, File.ReadAllBytes(fileName)); } } @@ -171,23 +172,23 @@ public void NibbleFile_Load() { using (var binaryFile = new FileMappedBuffer(PagedFileDescriptor.From(fileName, 1, 1))) { // Check pages 1 & 2 - Assert.AreEqual(2, binaryFile.Pages.Count()); - Assert.IsTrue(binaryFile.Pages[0].State == PageState.Unloaded); - Assert.AreEqual(0, binaryFile.Pages[0].StartIndex); - Assert.AreEqual(1, binaryFile.Pages[0].Count); - Assert.AreEqual(0, binaryFile.Pages[0].EndIndex); - Assert.IsFalse(binaryFile.Pages[0].Dirty); - - Assert.IsTrue(binaryFile.Pages[1].State == PageState.Unloaded); - Assert.AreEqual(1, binaryFile.Pages[1].StartIndex); - Assert.AreEqual(1, binaryFile.Pages[1].Count); - Assert.AreEqual(1, binaryFile.Pages[1].EndIndex); + ClassicAssert.AreEqual(2, binaryFile.Pages.Count()); + ClassicAssert.IsTrue(binaryFile.Pages[0].State == PageState.Unloaded); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].StartIndex); + ClassicAssert.AreEqual(1, binaryFile.Pages[0].Count); + ClassicAssert.AreEqual(0, binaryFile.Pages[0].EndIndex); + ClassicAssert.IsFalse(binaryFile.Pages[0].Dirty); + + ClassicAssert.IsTrue(binaryFile.Pages[1].State == PageState.Unloaded); + ClassicAssert.AreEqual(1, binaryFile.Pages[1].StartIndex); + ClassicAssert.AreEqual(1, binaryFile.Pages[1].Count); + ClassicAssert.AreEqual(1, binaryFile.Pages[1].EndIndex); // Check values - Assert.AreEqual(expected, binaryFile); + ClassicAssert.AreEqual(expected, binaryFile); } // Check file unchanged - Assert.AreEqual(expected, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(expected, File.ReadAllBytes(fileName)); } } @@ -200,7 +201,7 @@ public void ReadOnly_SinglePage() { using (var binaryFile = new FileMappedBuffer(PagedFileDescriptor.From (fileName, 8, 4*8))) { for (var i = 0; i < 8; i++) - Assert.AreEqual(expected[i], binaryFile[i]); + ClassicAssert.AreEqual(expected[i], binaryFile[i]); } } @@ -213,7 +214,7 @@ public void ReadOnly_MultiPage() { using (var binaryFile = new FileMappedBuffer(PagedFileDescriptor.From(fileName, 8, 4 * 8))) { for (var i = 0; i < 256; i++) - Assert.AreEqual(expected[i], binaryFile[i]); + ClassicAssert.AreEqual(expected[i], binaryFile[i]); } } @@ -228,14 +229,14 @@ public void ReadOnly_Update() { QuickSorter.Sort(binaryFile, Comparer.Default); for (var i = 0; i < 256; i++) - Assert.AreEqual(expected[i], binaryFile[i]); + ClassicAssert.AreEqual(expected[i], binaryFile[i]); } // check file is as expected using (var binaryFile = new FileMappedBuffer(PagedFileDescriptor.From(fileName, 8, 4 * 8))) { for (var i = 0; i < 256; i++) - Assert.AreEqual(expected[i], binaryFile[i]); + ClassicAssert.AreEqual(expected[i], binaryFile[i]); } } } diff --git a/tests/Hydrogen.Tests/Collections/Buffer/MerklePagedBufferTest.cs b/tests/Hydrogen.Tests/Collections/Buffer/MerklePagedBufferTest.cs index b49d953b6..a94f0df97 100644 --- a/tests/Hydrogen.Tests/Collections/Buffer/MerklePagedBufferTest.cs +++ b/tests/Hydrogen.Tests/Collections/Buffer/MerklePagedBufferTest.cs @@ -11,6 +11,7 @@ using System.Linq; using NUnit.Framework; using System.IO; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -24,7 +25,7 @@ public void SingleByte([Values(1, 2, 1 << 18)] int pageSize, [Values(CHF.SHA2_25 var data = new byte[] { 0 }; list.AddRange(data); var dataHash = Hashers.Hash(chf, data); - Assert.AreEqual(dataHash, list.MerkleTree.Root); + ClassicAssert.AreEqual(dataHash, list.MerkleTree.Root); } } @@ -45,7 +46,7 @@ public void ThreePages_AddPagesManually([Values(1, 2, 1 << 18)] int pageSize, [V refTree.Leafs.Add(Hash(page2Data)); refTree.Leafs.Add(Hash(page3Data)); - Assert.AreEqual(refTree.Root, list.MerkleTree.Root); + ClassicAssert.AreEqual(refTree.Root, list.MerkleTree.Root); } byte[] Hash(byte[] data) => Hashers.Hash(chf, data); @@ -66,7 +67,7 @@ public void ThreePages_AddPagesAuto([Values(1, 2, 1 << 18)] int pageSize, [Value refTree.Leafs.Add(Hash(page2Data)); refTree.Leafs.Add(Hash(page3Data)); - Assert.AreEqual(refTree.Root, list.MerkleTree.Root); + ClassicAssert.AreEqual(refTree.Root, list.MerkleTree.Root); } byte[] Hash(byte[] data) => Hashers.Hash(chf, data); @@ -91,7 +92,7 @@ public void ThreePages_UpdatePage([Values(1, 2, 1 << 18)] int pageSize, [Values( refTree.Leafs.Add(Hash(page2Data_2)); refTree.Leafs.Add(Hash(page3Data)); - Assert.AreEqual(refTree.Root, list.MerkleTree.Root); + ClassicAssert.AreEqual(refTree.Root, list.MerkleTree.Root); } byte[] Hash(byte[] data) => Hashers.Hash(chf, data); @@ -115,7 +116,7 @@ public void IntegrationTests_CheckEnd( IEnumerable newItems = RNG.NextBytes(newItemsCount); merkleBuffer.AddRange(newItems); expected.AddRange(newItems); - Assert.AreEqual(expected, merkleBuffer); + ClassicAssert.AreEqual(expected, merkleBuffer); // update a random amount if (merkleBuffer.Count > 0) { @@ -147,7 +148,7 @@ void CheckRoot() { var refTree = new SimpleMerkleTree(chf); foreach (var pageData in expected.Partition(pageSize)) refTree.Leafs.Add(Hash(pageData.ToArray())); - Assert.AreEqual(refTree.Root, merkleBuffer.MerkleTree.Root); + ClassicAssert.AreEqual(refTree.Root, merkleBuffer.MerkleTree.Root); } } diff --git a/tests/Hydrogen.Tests/Collections/Buffer/PagedBufferImplementationHelperTests.cs b/tests/Hydrogen.Tests/Collections/Buffer/PagedBufferImplementationHelperTests.cs index 7a9fc94bd..484f3035a 100644 --- a/tests/Hydrogen.Tests/Collections/Buffer/PagedBufferImplementationHelperTests.cs +++ b/tests/Hydrogen.Tests/Collections/Buffer/PagedBufferImplementationHelperTests.cs @@ -8,6 +8,7 @@ using System; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -23,6 +24,6 @@ public void ReadSpan([Values(0, 10, 99, 1)] int startIndex, [Values(1000, 990, 1 int endIndex = startIndex + count; var span = buffer.ReadSpan(startIndex, count); - Assert.AreEqual(input[startIndex..endIndex], span.ToArray()); + ClassicAssert.AreEqual(input[startIndex..endIndex], span.ToArray()); } } diff --git a/tests/Hydrogen.Tests/Collections/Dictionaries/BijectiveDictionaryTests.cs b/tests/Hydrogen.Tests/Collections/Dictionaries/BijectiveDictionaryTests.cs index 1f0667f97..7027d3fb5 100644 --- a/tests/Hydrogen.Tests/Collections/Dictionaries/BijectiveDictionaryTests.cs +++ b/tests/Hydrogen.Tests/Collections/Dictionaries/BijectiveDictionaryTests.cs @@ -8,6 +8,7 @@ using System.Collections.Generic; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -85,7 +86,7 @@ public void TestUpdateViaBijection() { dictionary.Bijection[1] = "one updated"; Assert.That(dictionary.Count, Is.EqualTo(1)); - CollectionAssert.AreEqual(dictionary.Keys, new [] { "one updated" }); - CollectionAssert.AreEqual(dictionary.Values, new [] { 1 }); + ClassicAssert.AreEqual(dictionary.Keys, new [] { "one updated" }); + ClassicAssert.AreEqual(dictionary.Values, new [] { 1 }); } } diff --git a/tests/Hydrogen.Tests/Collections/Dictionaries/MultiKeyDictionaryTest.cs b/tests/Hydrogen.Tests/Collections/Dictionaries/MultiKeyDictionaryTest.cs index 0d61c1940..60bd80dfa 100644 --- a/tests/Hydrogen.Tests/Collections/Dictionaries/MultiKeyDictionaryTest.cs +++ b/tests/Hydrogen.Tests/Collections/Dictionaries/MultiKeyDictionaryTest.cs @@ -12,6 +12,7 @@ //----------------------------------------------------------------------- using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -28,15 +29,15 @@ public void TestSimple() { dict.Add(21, "2", "1"); dict.Add(22, "2", "2"); - Assert.True(dict.ContainsKey("1", "1")); - Assert.True(dict.ContainsKey("1", "2")); - Assert.True(dict.ContainsKey("2", "1")); - Assert.True(dict.ContainsKey("2", "2")); + ClassicAssert.IsTrue(dict.ContainsKey("1", "1")); + ClassicAssert.IsTrue(dict.ContainsKey("1", "2")); + ClassicAssert.IsTrue(dict.ContainsKey("2", "1")); + ClassicAssert.IsTrue(dict.ContainsKey("2", "2")); - Assert.AreEqual(11, dict["1", "1"]); - Assert.AreEqual(12, dict["1", "2"]); - Assert.AreEqual(21, dict["2", "1"]); - Assert.AreEqual(22, dict["2", "2"]); + ClassicAssert.AreEqual(11, dict["1", "1"]); + ClassicAssert.AreEqual(12, dict["1", "2"]); + ClassicAssert.AreEqual(21, dict["2", "1"]); + ClassicAssert.AreEqual(22, dict["2", "2"]); } @@ -44,7 +45,7 @@ public void TestSimple() { public void LookupObjectKey_SameNumericTypeCode() { var dict = new EnumerableKeyDictionary(); dict.Add("magic", (int)1); - Assert.True(dict.ContainsKey((int)1)); + ClassicAssert.IsTrue(dict.ContainsKey((int)1)); } @@ -52,28 +53,28 @@ public void LookupObjectKey_SameNumericTypeCode() { public void LookupObjectKey_VaryingNumericTypeCode_1() { var dict = new EnumerableKeyDictionary(); dict.Add("magic", (int)1); - Assert.True(dict.ContainsKey((uint)1)); + ClassicAssert.IsTrue(dict.ContainsKey((uint)1)); } [Test] public void LookupObjectKey_VaryingNumericTypeCode_2() { var dict = new EnumerableKeyDictionary(); dict.Add("magic", (sbyte)1); - Assert.True(dict.ContainsKey((ulong)1)); + ClassicAssert.IsTrue(dict.ContainsKey((ulong)1)); } [Test] public void LookupObjectKey_VaryingNumericTypeCode_3() { var dict = new EnumerableKeyDictionary(); dict.Add("magic", (int)1); - Assert.True(dict.ContainsKey((long)1)); + ClassicAssert.IsTrue(dict.ContainsKey((long)1)); } [Test] public void LookupObjectKey_VaryingNumericTypeCode_4() { var dict = new EnumerableKeyDictionary(); dict.Add("magic", (float)1); - Assert.True(dict.ContainsKey((double)1)); + ClassicAssert.IsTrue(dict.ContainsKey((double)1)); } } diff --git a/tests/Hydrogen.Tests/Collections/Dictionaries/ReferenceDictionaryTests.cs b/tests/Hydrogen.Tests/Collections/Dictionaries/ReferenceDictionaryTests.cs index 5ad39811d..575c9cf97 100644 --- a/tests/Hydrogen.Tests/Collections/Dictionaries/ReferenceDictionaryTests.cs +++ b/tests/Hydrogen.Tests/Collections/Dictionaries/ReferenceDictionaryTests.cs @@ -9,6 +9,7 @@ using System.Collections.Generic; using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -24,8 +25,8 @@ public void Test_Add() { referenceDictionary[key2] = 2; referenceDictionary["one"] = 3; // overwrite key1 value since compiler re-uses string literals Assert.That(referenceDictionary.Count, Is.EqualTo(2)); - CollectionAssert.AreEqual(referenceDictionary.Keys.ToArray(), new [] { key1, key2 }); - CollectionAssert.AreEqual(referenceDictionary.Values.ToArray(), new [] { 3, 2 }); + ClassicAssert.AreEqual(referenceDictionary.Keys.ToArray(), new [] { key1, key2 }); + ClassicAssert.AreEqual(referenceDictionary.Values.ToArray(), new [] { 3, 2 }); } [Test] @@ -36,7 +37,7 @@ public void Test_Remove() { referenceDictionary[key1] = 1; referenceDictionary[key2] = 2; referenceDictionary.Remove("one"); // remove key1 value since compiler re-uses string literals - CollectionAssert.AreEqual(referenceDictionary.Keys.ToArray(), new [] { key2 }); - CollectionAssert.AreEqual(referenceDictionary.Values.ToArray(), new [] { 2 }); + ClassicAssert.AreEqual(referenceDictionary.Keys.ToArray(), new [] { key2 }); + ClassicAssert.AreEqual(referenceDictionary.Values.ToArray(), new [] { 2 }); } } diff --git a/tests/Hydrogen.Tests/Collections/Lists/RecyclableListTestsBase.cs b/tests/Hydrogen.Tests/Collections/Lists/RecyclableListTestsBase.cs index f44becba4..f3e95f093 100644 --- a/tests/Hydrogen.Tests/Collections/Lists/RecyclableListTestsBase.cs +++ b/tests/Hydrogen.Tests/Collections/Lists/RecyclableListTestsBase.cs @@ -14,6 +14,7 @@ using System.Text; using Hydrogen.NUnit; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -31,7 +32,7 @@ public void WalkThrough() { Assert.That(rlist.RecycledCount, Is.EqualTo(0)); // Enumerate empty - CollectionAssert.AreEqual(rlist, Array.Empty()); + ClassicAssert.AreEqual(rlist, Array.Empty()); // add "A" rlist.Add("A"); @@ -64,7 +65,7 @@ public void WalkThrough() { Assert.That(() => rlist.RemoveAt(1), Throws.ArgumentException); // Enumerate - CollectionAssert.AreEqual(rlist, new[] { "A", "C" }); + ClassicAssert.AreEqual(rlist, new[] { "A", "C" }); Assert.That(rlist.Count, Is.EqualTo(2)); Assert.That(rlist.ListCount, Is.EqualTo(3)); Assert.That(rlist.RecycledCount, Is.EqualTo(1)); @@ -87,7 +88,7 @@ public void WalkThrough() { Assert.That(rlist.Read(1), Is.EqualTo("B2")); // Enumeration check - CollectionAssert.AreEqual(rlist, new[] { "A", "B2", "C" }); + ClassicAssert.AreEqual(rlist, new[] { "A", "B2", "C" }); // add another "A" (verify used new index) rlist.Add("A"); @@ -129,7 +130,7 @@ public void WalkThrough() { Assert.That(rlist.IndexOf("C"), Is.EqualTo(2)); // Enumerate "B2" and "C" - CollectionAssert.AreEqual(rlist, new[] { "B2", "C" }); + ClassicAssert.AreEqual(rlist, new[] { "B2", "C" }); // Clear rlist.Clear(); diff --git a/tests/Hydrogen.Tests/Collections/Lists/UpdateOnlyListTests.cs b/tests/Hydrogen.Tests/Collections/Lists/UpdateOnlyListTests.cs index 031caed8a..035a819d7 100644 --- a/tests/Hydrogen.Tests/Collections/Lists/UpdateOnlyListTests.cs +++ b/tests/Hydrogen.Tests/Collections/Lists/UpdateOnlyListTests.cs @@ -9,6 +9,7 @@ using System.Linq; using NUnit.Framework; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -17,12 +18,12 @@ public class UpdateOnlyListTests { [Test] public void AddRange() { var list = new UpdateOnlyList(10, () => default); - Assert.IsTrue(list.All(x => x == default)); + ClassicAssert.IsTrue(list.All(x => x == default)); list.AddRange(Enumerable.Range(0, 5)); list.AddRange(Enumerable.Range(5, 5)); - Assert.AreEqual(Enumerable.Range(0, 10).ToList(), list); + ClassicAssert.AreEqual(Enumerable.Range(0, 10).ToList(), list); } [Test] @@ -31,7 +32,7 @@ public void Insert_Basic() { var list = new UpdateOnlyList(store, 0, PreAllocationPolicy.Fixed, 3, () => default); list.AddRange(new[] { 1, 3 }); list.Insert(1, 2); - Assert.AreEqual(new[] { 1, 2, 3 }, list); + ClassicAssert.AreEqual(new[] { 1, 2, 3 }, list); } [Test] @@ -40,7 +41,7 @@ public void InsertAtIndex() { ExtendedList list = new ExtendedList(input); UpdateOnlyList preallocatedList = new UpdateOnlyList(list, 0, PreAllocationPolicy.Fixed, 10, () => default); preallocatedList.InsertRange(0, input.Reverse()); - Assert.AreEqual(input.Reverse(), list); + ClassicAssert.AreEqual(input.Reverse(), list); } [Test] @@ -52,7 +53,7 @@ public void RemoveAtIndex() { preallocatedList.RemoveRange(0, preallocatedList.Count); - Assert.IsTrue(preallocatedList.All(x => x == default)); + ClassicAssert.IsTrue(preallocatedList.All(x => x == default)); } [Test] diff --git a/tests/Hydrogen.Tests/Collections/Other/BitVectorTests.cs b/tests/Hydrogen.Tests/Collections/Other/BitVectorTests.cs index b22bf0820..548442fce 100644 --- a/tests/Hydrogen.Tests/Collections/Other/BitVectorTests.cs +++ b/tests/Hydrogen.Tests/Collections/Other/BitVectorTests.cs @@ -11,6 +11,7 @@ using System.Linq; using NUnit.Framework; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -28,7 +29,7 @@ public void InsertRangeEnd() { var insert = Enumerable.Repeat(false, 20).ToArray(); list.InsertRange(20, insert); - Assert.AreEqual(inputs.Concat(insert), list); + ClassicAssert.AreEqual(inputs.Concat(insert), list); } [Test] @@ -39,12 +40,12 @@ public void ReadRange() { var inputs = random.NextBools(16); list.AddRange(inputs); - Assert.AreEqual(inputs, list); + ClassicAssert.AreEqual(inputs, list); var range = list.ReadRange(9, 7) .ToList(); - Assert.AreEqual(inputs[9..], range); + ClassicAssert.AreEqual(inputs[9..], range); } [Test] @@ -56,8 +57,8 @@ public void IndexOfRange() { var inputs = new[] { false, false, false, false, false, false, false, false, true }; list.AddRange(inputs); - Assert.AreEqual(new[] { 8, 8, 8 }, list.IndexOfRange(new[] { true, true, true })); - Assert.AreEqual(new[] { 7 }, list.IndexOfRange(new[] { false })); + ClassicAssert.AreEqual(new[] { 8, 8, 8 }, list.IndexOfRange(new[] { true, true, true })); + ClassicAssert.AreEqual(new[] { 7 }, list.IndexOfRange(new[] { false })); } [Test] @@ -69,11 +70,11 @@ public void RemoveRange() { list.AddRange(inputs); list.RemoveRange(8, 1); - Assert.AreEqual(8, list.Count); - Assert.AreEqual(inputs[..^1], list); + ClassicAssert.AreEqual(8, list.Count); + ClassicAssert.AreEqual(inputs[..^1], list); list.RemoveRange(0, list.Count); - Assert.AreEqual(0, list.Count); + ClassicAssert.AreEqual(0, list.Count); } [Test] @@ -92,7 +93,7 @@ public void UpdateRange() { list.UpdateRange(0, update); expected.UpdateRange(0, update); - Assert.AreEqual(expected, list); + ClassicAssert.AreEqual(expected, list); int randomIndex = random.Next(0, (int)list.Count - 1); var randomUpdate = random.NextBools((int)list.Count - randomIndex); @@ -100,7 +101,7 @@ public void UpdateRange() { list.UpdateRange(randomIndex, randomUpdate); expected.UpdateRange(randomIndex, randomUpdate); - Assert.AreEqual(expected, list); + ClassicAssert.AreEqual(expected, list); } [Test] diff --git a/tests/Hydrogen.Tests/Collections/Other/EnumerableExtensionTests.cs b/tests/Hydrogen.Tests/Collections/Other/EnumerableExtensionTests.cs index 2ba194dad..ac8e725be 100644 --- a/tests/Hydrogen.Tests/Collections/Other/EnumerableExtensionTests.cs +++ b/tests/Hydrogen.Tests/Collections/Other/EnumerableExtensionTests.cs @@ -9,6 +9,7 @@ using System; using NUnit.Framework; using System.Linq; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -46,7 +47,7 @@ public void TestOrderByAll() { for (var i = 0; i < 6; i++) { for (var j = 0; j < 2; j++) { - Assert.AreEqual(expected[i][j], actual.ElementAt(i).ElementAt(j)); + ClassicAssert.AreEqual(expected[i][j], actual.ElementAt(i).ElementAt(j)); } } @@ -61,7 +62,7 @@ public void PartitionBySize(int length, int partSize, int expectedParts) { var input = rando.NextBytes(length); var parts = input.PartitionBySize(x => 1, partSize); - Assert.AreEqual(expectedParts, parts.Count()); - Assert.AreEqual(input, parts.Aggregate((x, y) => x.Concat(y))); + ClassicAssert.AreEqual(expectedParts, parts.Count()); + ClassicAssert.AreEqual(input, parts.Aggregate((x, y) => x.Concat(y))); } } diff --git a/tests/Hydrogen.Tests/Collections/Paged/MemoryPagedListTests.cs b/tests/Hydrogen.Tests/Collections/Paged/MemoryPagedListTests.cs index cb6280c5a..40a4c62e8 100644 --- a/tests/Hydrogen.Tests/Collections/Paged/MemoryPagedListTests.cs +++ b/tests/Hydrogen.Tests/Collections/Paged/MemoryPagedListTests.cs @@ -11,6 +11,7 @@ using System.Linq; using NUnit.Framework; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -25,19 +26,19 @@ public void SinglePage([Values(1, 17)] int itemSize) { using (var collection = new MemoryPagedList(pageSize, 1 * pageSize, itemSize)) { collection.Add(10); // Check page - Assert.AreEqual(1, collection.Pages.Count()); - Assert.AreEqual(0, collection.Pages[0].Number); - Assert.AreEqual(pageSize, collection.Pages[0].MaxSize); - Assert.AreEqual(0, collection.Pages[0].StartIndex); - Assert.AreEqual(1, collection.Pages[0].Count); - Assert.AreEqual(0, collection.Pages[0].EndIndex); - Assert.AreEqual(pageSize, collection.Pages[0].Size); - Assert.IsTrue(collection.Pages[0].Dirty); + ClassicAssert.AreEqual(1, collection.Pages.Count()); + ClassicAssert.AreEqual(0, collection.Pages[0].Number); + ClassicAssert.AreEqual(pageSize, collection.Pages[0].MaxSize); + ClassicAssert.AreEqual(0, collection.Pages[0].StartIndex); + ClassicAssert.AreEqual(1, collection.Pages[0].Count); + ClassicAssert.AreEqual(0, collection.Pages[0].EndIndex); + ClassicAssert.AreEqual(pageSize, collection.Pages[0].Size); + ClassicAssert.IsTrue(collection.Pages[0].Dirty); // Check value - Assert.AreEqual(10, collection[0]); - Assert.AreEqual(1, collection.Count); - Assert.AreEqual(1 * itemSize, collection.CalculateTotalSize()); + ClassicAssert.AreEqual(10, collection[0]); + ClassicAssert.AreEqual(1, collection.Count); + ClassicAssert.AreEqual(1 * itemSize, collection.CalculateTotalSize()); } } @@ -49,47 +50,47 @@ public void TwoPages([Values(1, 17)] int itemSize) { collection.Add(10); // Check Page 1 - Assert.AreEqual(1, collection.Pages.Count()); - Assert.IsTrue(collection.Pages[0].State == PageState.Loaded); - Assert.AreEqual(0, collection.Pages[0].Number); - Assert.AreEqual(pageSize, collection.Pages[0].MaxSize); - Assert.AreEqual(0, collection.Pages[0].StartIndex); - Assert.AreEqual(1, collection.Pages[0].Count); - Assert.AreEqual(0, collection.Pages[0].EndIndex); - Assert.AreEqual(pageSize, collection.Pages[0].Size); - Assert.IsTrue(collection.Pages[0].Dirty); + ClassicAssert.AreEqual(1, collection.Pages.Count()); + ClassicAssert.IsTrue(collection.Pages[0].State == PageState.Loaded); + ClassicAssert.AreEqual(0, collection.Pages[0].Number); + ClassicAssert.AreEqual(pageSize, collection.Pages[0].MaxSize); + ClassicAssert.AreEqual(0, collection.Pages[0].StartIndex); + ClassicAssert.AreEqual(1, collection.Pages[0].Count); + ClassicAssert.AreEqual(0, collection.Pages[0].EndIndex); + ClassicAssert.AreEqual(pageSize, collection.Pages[0].Size); + ClassicAssert.IsTrue(collection.Pages[0].Dirty); // Add new page collection.Add(20); // Check pages 1 & 2 - Assert.AreEqual(2, collection.Pages.Count()); - Assert.IsTrue(collection.Pages[0].State == PageState.Unloaded); - Assert.AreEqual(0, collection.Pages[0].Number); - Assert.AreEqual(pageSize, collection.Pages[0].MaxSize); - Assert.AreEqual(0, collection.Pages[0].StartIndex); - Assert.AreEqual(1, collection.Pages[0].Count); - Assert.AreEqual(0, collection.Pages[0].EndIndex); - Assert.AreEqual(pageSize, collection.Pages[0].Size); - - - Assert.IsTrue(collection.Pages[1].State == PageState.Loaded); - Assert.AreEqual(1, collection.Pages[1].Number); - Assert.AreEqual(pageSize, collection.Pages[1].MaxSize); - Assert.AreEqual(1, collection.Pages[1].StartIndex); - Assert.AreEqual(1, collection.Pages[1].Count); - Assert.AreEqual(1, collection.Pages[1].EndIndex); - Assert.AreEqual(pageSize, collection.Pages[1].Size); - Assert.IsTrue(collection.Pages[1].Dirty); + ClassicAssert.AreEqual(2, collection.Pages.Count()); + ClassicAssert.IsTrue(collection.Pages[0].State == PageState.Unloaded); + ClassicAssert.AreEqual(0, collection.Pages[0].Number); + ClassicAssert.AreEqual(pageSize, collection.Pages[0].MaxSize); + ClassicAssert.AreEqual(0, collection.Pages[0].StartIndex); + ClassicAssert.AreEqual(1, collection.Pages[0].Count); + ClassicAssert.AreEqual(0, collection.Pages[0].EndIndex); + ClassicAssert.AreEqual(pageSize, collection.Pages[0].Size); + + + ClassicAssert.IsTrue(collection.Pages[1].State == PageState.Loaded); + ClassicAssert.AreEqual(1, collection.Pages[1].Number); + ClassicAssert.AreEqual(pageSize, collection.Pages[1].MaxSize); + ClassicAssert.AreEqual(1, collection.Pages[1].StartIndex); + ClassicAssert.AreEqual(1, collection.Pages[1].Count); + ClassicAssert.AreEqual(1, collection.Pages[1].EndIndex); + ClassicAssert.AreEqual(pageSize, collection.Pages[1].Size); + ClassicAssert.IsTrue(collection.Pages[1].Dirty); // Check values - Assert.AreEqual(10, collection[0]); - Assert.AreEqual(20, collection[1]); + ClassicAssert.AreEqual(10, collection[0]); + ClassicAssert.AreEqual(20, collection[1]); // Check size - Assert.AreEqual(collection.Pages[0].Size, itemSize); - Assert.AreEqual(collection.Pages[1].Size, itemSize); - Assert.AreEqual(collection.CalculateTotalSize(), 2 * itemSize); + ClassicAssert.AreEqual(collection.Pages[0].Size, itemSize); + ClassicAssert.AreEqual(collection.Pages[1].Size, itemSize); + ClassicAssert.AreEqual(collection.CalculateTotalSize(), 2 * itemSize); } } @@ -105,127 +106,127 @@ public void SizeByCount_Integration([Values(1, 17)] int itemSize) { collection.PageDeleted += (o, page) => deletes++; collection.PageLoaded += (o, page) => loads++; collection.PageUnloaded += (o, page) => unloads++; - Assert.AreEqual(0, created); - Assert.AreEqual(0, loads); - Assert.AreEqual(0, unloads); - Assert.AreEqual(collection.Count, 0); - Assert.AreEqual(collection.Pages.Count, 0); + ClassicAssert.AreEqual(0, created); + ClassicAssert.AreEqual(0, loads); + ClassicAssert.AreEqual(0, unloads); + ClassicAssert.AreEqual(collection.Count, 0); + ClassicAssert.AreEqual(collection.Pages.Count, 0); AssertEx.HasLoadedPages(collection, Array.Empty()); collection.Add("page1"); - Assert.AreEqual(1, created); - Assert.AreEqual(1, loads); - Assert.AreEqual(0, unloads); - Assert.AreEqual(collection.Count, 1); - Assert.AreEqual(collection.Pages.Count, 1); + ClassicAssert.AreEqual(1, created); + ClassicAssert.AreEqual(1, loads); + ClassicAssert.AreEqual(0, unloads); + ClassicAssert.AreEqual(collection.Count, 1); + ClassicAssert.AreEqual(collection.Pages.Count, 1); AssertEx.HasLoadedPages(collection, 0); collection.Add("page1.1"); - Assert.AreEqual(1, created); - Assert.AreEqual(1, loads); - Assert.AreEqual(0, unloads); - Assert.AreEqual(collection.Count, 2); - Assert.AreEqual(collection.Pages.Count, 1); + ClassicAssert.AreEqual(1, created); + ClassicAssert.AreEqual(1, loads); + ClassicAssert.AreEqual(0, unloads); + ClassicAssert.AreEqual(collection.Count, 2); + ClassicAssert.AreEqual(collection.Pages.Count, 1); AssertEx.HasLoadedPages(collection, 0); collection.Add("page2"); - Assert.AreEqual(2, created); - Assert.AreEqual(2, loads); - Assert.AreEqual(0, unloads); - Assert.AreEqual(collection.Count, 3); - Assert.AreEqual(collection.Pages.Count, 2); + ClassicAssert.AreEqual(2, created); + ClassicAssert.AreEqual(2, loads); + ClassicAssert.AreEqual(0, unloads); + ClassicAssert.AreEqual(collection.Count, 3); + ClassicAssert.AreEqual(collection.Pages.Count, 2); AssertEx.HasLoadedPages(collection, 0, 1); collection.Add("page2.2"); - Assert.AreEqual(2, created); - Assert.AreEqual(2, loads); - Assert.AreEqual(0, unloads); - Assert.AreEqual(collection.Count, 4); - Assert.AreEqual(collection.Pages.Count, 2); + ClassicAssert.AreEqual(2, created); + ClassicAssert.AreEqual(2, loads); + ClassicAssert.AreEqual(0, unloads); + ClassicAssert.AreEqual(collection.Count, 4); + ClassicAssert.AreEqual(collection.Pages.Count, 2); AssertEx.HasLoadedPages(collection, 0, 1); // should be two pages open collection.Add("page3"); - Assert.AreEqual(3, created); - Assert.AreEqual(3, loads); - Assert.AreEqual(1, unloads); - Assert.AreEqual(collection.Pages.Count, 3); + ClassicAssert.AreEqual(3, created); + ClassicAssert.AreEqual(3, loads); + ClassicAssert.AreEqual(1, unloads); + ClassicAssert.AreEqual(collection.Pages.Count, 3); AssertEx.HasLoadedPages(collection, 1, 2); collection.Add("page3.3"); - Assert.AreEqual(3, created); - Assert.AreEqual(3, loads); - Assert.AreEqual(1, unloads); - Assert.AreEqual(collection.Pages.Count, 3); + ClassicAssert.AreEqual(3, created); + ClassicAssert.AreEqual(3, loads); + ClassicAssert.AreEqual(1, unloads); + ClassicAssert.AreEqual(collection.Pages.Count, 3); AssertEx.HasLoadedPages(collection, 1, 2); // read from page[2] a few times to increase demand ticker var xxx = collection[5] + collection[5]; collection.Add("page4"); - Assert.AreEqual(4, created); - Assert.AreEqual(4, loads); - Assert.AreEqual(2, unloads); - Assert.AreEqual(collection.Pages.Count, 4); + ClassicAssert.AreEqual(4, created); + ClassicAssert.AreEqual(4, loads); + ClassicAssert.AreEqual(2, unloads); + ClassicAssert.AreEqual(collection.Pages.Count, 4); AssertEx.HasLoadedPages(collection, 2, 3); // read from page[3] several times to increase demand ticker xxx = collection[6] + collection[6] + collection[6] + collection[6] + collection[6] + collection[6] + collection[6] + collection[6]; var item = collection[0]; - Assert.AreEqual(4, created); - Assert.AreEqual(5, loads); - Assert.AreEqual(3, unloads); - Assert.AreEqual(collection.Pages.Count, 4); - Assert.AreEqual(item, "page1"); + ClassicAssert.AreEqual(4, created); + ClassicAssert.AreEqual(5, loads); + ClassicAssert.AreEqual(3, unloads); + ClassicAssert.AreEqual(collection.Pages.Count, 4); + ClassicAssert.AreEqual(item, "page1"); AssertEx.HasLoadedPages(collection, 3, 0); item = collection[1]; - Assert.AreEqual(4, created); - Assert.AreEqual(5, loads); - Assert.AreEqual(3, unloads); - Assert.AreEqual(collection.Pages.Count, 4); - Assert.AreEqual(item, "page1.1"); + ClassicAssert.AreEqual(4, created); + ClassicAssert.AreEqual(5, loads); + ClassicAssert.AreEqual(3, unloads); + ClassicAssert.AreEqual(collection.Pages.Count, 4); + ClassicAssert.AreEqual(item, "page1.1"); AssertEx.HasLoadedPages(collection, 3, 0); item = collection[2]; - Assert.AreEqual(4, created); - Assert.AreEqual(6, loads); - Assert.AreEqual(4, unloads); - Assert.AreEqual(collection.Pages.Count, 4); - Assert.AreEqual(item, "page2"); + ClassicAssert.AreEqual(4, created); + ClassicAssert.AreEqual(6, loads); + ClassicAssert.AreEqual(4, unloads); + ClassicAssert.AreEqual(collection.Pages.Count, 4); + ClassicAssert.AreEqual(item, "page2"); AssertEx.HasLoadedPages(collection, 3, 1); item = collection[3]; - Assert.AreEqual(4, created); - Assert.AreEqual(6, loads); - Assert.AreEqual(4, unloads); - Assert.AreEqual(collection.Pages.Count, 4); - Assert.AreEqual(item, "page2.2"); + ClassicAssert.AreEqual(4, created); + ClassicAssert.AreEqual(6, loads); + ClassicAssert.AreEqual(4, unloads); + ClassicAssert.AreEqual(collection.Pages.Count, 4); + ClassicAssert.AreEqual(item, "page2.2"); AssertEx.HasLoadedPages(collection, 3, 1); item = collection[4]; - Assert.AreEqual(4, created); - Assert.AreEqual(7, loads); - Assert.AreEqual(5, unloads); - Assert.AreEqual(collection.Pages.Count, 4); - Assert.AreEqual(item, "page3"); + ClassicAssert.AreEqual(4, created); + ClassicAssert.AreEqual(7, loads); + ClassicAssert.AreEqual(5, unloads); + ClassicAssert.AreEqual(collection.Pages.Count, 4); + ClassicAssert.AreEqual(item, "page3"); AssertEx.HasLoadedPages(collection, 3, 2); item = collection[5]; - Assert.AreEqual(4, created); - Assert.AreEqual(7, loads); - Assert.AreEqual(5, unloads); - Assert.AreEqual(collection.Pages.Count, 4); - Assert.AreEqual(item, "page3.3"); + ClassicAssert.AreEqual(4, created); + ClassicAssert.AreEqual(7, loads); + ClassicAssert.AreEqual(5, unloads); + ClassicAssert.AreEqual(collection.Pages.Count, 4); + ClassicAssert.AreEqual(item, "page3.3"); AssertEx.HasLoadedPages(collection, 3, 2); item = collection[6]; - Assert.AreEqual(4, created); - Assert.AreEqual(7, loads); - Assert.AreEqual(5, unloads); - Assert.AreEqual(collection.Pages.Count, 4); - Assert.AreEqual(item, "page4"); + ClassicAssert.AreEqual(4, created); + ClassicAssert.AreEqual(7, loads); + ClassicAssert.AreEqual(5, unloads); + ClassicAssert.AreEqual(collection.Pages.Count, 4); + ClassicAssert.AreEqual(item, "page4"); AssertEx.HasLoadedPages(collection, 3, 2); // Remove an illegal subrange @@ -233,10 +234,10 @@ public void SizeByCount_Integration([Values(1, 17)] int itemSize) { // remove some items collection.RemoveRange(3, 4); - Assert.AreEqual(collection.Pages.Count, 2); - Assert.AreEqual(collection.Count, 3); - Assert.AreEqual(collection.Last(), "page2"); - Assert.AreEqual(2, deletes); + ClassicAssert.AreEqual(collection.Pages.Count, 2); + ClassicAssert.AreEqual(collection.Count, 3); + ClassicAssert.AreEqual(collection.Last(), "page2"); + ClassicAssert.AreEqual(2, deletes); } } @@ -252,85 +253,85 @@ public void SizeByFunc_Integration() { collection.PageDeleted += (o, page) => deletes++; collection.PageLoaded += (o, page) => loads++; collection.PageUnloaded += (o, page) => unloads++; - Assert.AreEqual(0, created); - Assert.AreEqual(0, loads); - Assert.AreEqual(0, unloads); - Assert.AreEqual(collection.Count, 0); - Assert.AreEqual(collection.Pages.Count(), 0); + ClassicAssert.AreEqual(0, created); + ClassicAssert.AreEqual(0, loads); + ClassicAssert.AreEqual(0, unloads); + ClassicAssert.AreEqual(collection.Count, 0); + ClassicAssert.AreEqual(collection.Pages.Count(), 0); AssertEx.HasLoadedPages(collection, Array.Empty()); // page 1 collection.Add("01"); - Assert.AreEqual(1, created); - Assert.AreEqual(1, loads); - Assert.AreEqual(0, unloads); - Assert.AreEqual(collection.Count, 1); - Assert.AreEqual(collection.Pages.Count(), 1); - Assert.AreEqual(collection.Pages[0].Size, 2); + ClassicAssert.AreEqual(1, created); + ClassicAssert.AreEqual(1, loads); + ClassicAssert.AreEqual(0, unloads); + ClassicAssert.AreEqual(collection.Count, 1); + ClassicAssert.AreEqual(collection.Pages.Count(), 1); + ClassicAssert.AreEqual(collection.Pages[0].Size, 2); AssertEx.HasLoadedPages(collection, 0); collection.Add("2"); - Assert.AreEqual(1, created); - Assert.AreEqual(1, loads); - Assert.AreEqual(0, unloads); - Assert.AreEqual(collection.Count, 2); - Assert.AreEqual(collection.Pages.Count(), 1); - Assert.AreEqual(collection.Pages[0].Size, 3); + ClassicAssert.AreEqual(1, created); + ClassicAssert.AreEqual(1, loads); + ClassicAssert.AreEqual(0, unloads); + ClassicAssert.AreEqual(collection.Count, 2); + ClassicAssert.AreEqual(collection.Pages.Count(), 1); + ClassicAssert.AreEqual(collection.Pages[0].Size, 3); AssertEx.HasLoadedPages(collection, 0); // page 2 collection.Add("34"); - Assert.AreEqual(2, created); - Assert.AreEqual(2, loads); - Assert.AreEqual(0, unloads); - Assert.AreEqual(collection.Count, 3); - Assert.AreEqual(collection.Pages.Count(), 2); - Assert.AreEqual(collection.Pages[1].Size, 2); + ClassicAssert.AreEqual(2, created); + ClassicAssert.AreEqual(2, loads); + ClassicAssert.AreEqual(0, unloads); + ClassicAssert.AreEqual(collection.Count, 3); + ClassicAssert.AreEqual(collection.Pages.Count(), 2); + ClassicAssert.AreEqual(collection.Pages[1].Size, 2); AssertEx.HasLoadedPages(collection, 0, 1); // read this page[1] few times to bump ticker var xxx = collection[2] + collection[2]; // page 3 collection.Add("56"); - Assert.AreEqual(3, created); - Assert.AreEqual(3, loads); - Assert.AreEqual(1, unloads); - Assert.AreEqual(collection.Pages.Count(), 3); - Assert.AreEqual(collection.Pages[2].Size, 2); + ClassicAssert.AreEqual(3, created); + ClassicAssert.AreEqual(3, loads); + ClassicAssert.AreEqual(1, unloads); + ClassicAssert.AreEqual(collection.Pages.Count(), 3); + ClassicAssert.AreEqual(collection.Pages[2].Size, 2); AssertEx.HasLoadedPages(collection, 1, 2); // read this page[2] many times to bump ticker up xxx = collection[3] + collection[3] + collection[3] + collection[3]; var item = collection[0]; - Assert.AreEqual(3, created); - Assert.AreEqual(4, loads); - Assert.AreEqual(2, unloads); - Assert.AreEqual(collection.Pages.Count(), 3); - Assert.AreEqual(item, "01"); + ClassicAssert.AreEqual(3, created); + ClassicAssert.AreEqual(4, loads); + ClassicAssert.AreEqual(2, unloads); + ClassicAssert.AreEqual(collection.Pages.Count(), 3); + ClassicAssert.AreEqual(item, "01"); AssertEx.HasLoadedPages(collection, 2, 0); item = collection[1]; - Assert.AreEqual(3, created); - Assert.AreEqual(4, loads); - Assert.AreEqual(2, unloads); - Assert.AreEqual(collection.Pages.Count(), 3); - Assert.AreEqual(item, "2"); + ClassicAssert.AreEqual(3, created); + ClassicAssert.AreEqual(4, loads); + ClassicAssert.AreEqual(2, unloads); + ClassicAssert.AreEqual(collection.Pages.Count(), 3); + ClassicAssert.AreEqual(item, "2"); AssertEx.HasLoadedPages(collection, 2, 0); item = collection[2]; - Assert.AreEqual(3, created); - Assert.AreEqual(5, loads); - Assert.AreEqual(3, unloads); - Assert.AreEqual(collection.Pages.Count(), 3); - Assert.AreEqual(item, "34"); + ClassicAssert.AreEqual(3, created); + ClassicAssert.AreEqual(5, loads); + ClassicAssert.AreEqual(3, unloads); + ClassicAssert.AreEqual(collection.Pages.Count(), 3); + ClassicAssert.AreEqual(item, "34"); AssertEx.HasLoadedPages(collection, 2, 1); item = collection[3]; - Assert.AreEqual(3, created); - Assert.AreEqual(5, loads); - Assert.AreEqual(3, unloads); - Assert.AreEqual(collection.Pages.Count(), 3); - Assert.AreEqual(item, "56"); + ClassicAssert.AreEqual(3, created); + ClassicAssert.AreEqual(5, loads); + ClassicAssert.AreEqual(3, unloads); + ClassicAssert.AreEqual(collection.Pages.Count(), 3); + ClassicAssert.AreEqual(item, "56"); AssertEx.HasLoadedPages(collection, 2, 1); // Remove an illegal subrange @@ -338,10 +339,10 @@ public void SizeByFunc_Integration() { // remove some items collection.RemoveRange(1, 3); - Assert.AreEqual(collection.Pages.Count(), 1); - Assert.AreEqual(collection.Count, 1); - Assert.AreEqual(collection[0], "01"); - Assert.AreEqual(2, deletes); + ClassicAssert.AreEqual(collection.Pages.Count(), 1); + ClassicAssert.AreEqual(collection.Count, 1); + ClassicAssert.AreEqual(collection[0], "01"); + ClassicAssert.AreEqual(2, deletes); } } @@ -366,34 +367,34 @@ public void IterateLazilyLoadedPages() { // ensure lazily loads switch (item.Index) { case 0: - Assert.AreEqual(1, loads.Count); + ClassicAssert.AreEqual(1, loads.Count); break; case 1: - Assert.AreEqual(1, loads.Count); + ClassicAssert.AreEqual(1, loads.Count); break; case 2: - Assert.AreEqual(2, loads.Count); + ClassicAssert.AreEqual(2, loads.Count); break; case 3: - Assert.AreEqual(3, loads.Count); + ClassicAssert.AreEqual(3, loads.Count); break; case 4: - Assert.AreEqual(3, loads.Count); + ClassicAssert.AreEqual(3, loads.Count); break; } } - Assert.AreEqual(3, loads.Count); - Assert.AreEqual(3, unloads.Count); + ClassicAssert.AreEqual(3, loads.Count); + ClassicAssert.AreEqual(3, unloads.Count); - Assert.AreEqual(loads[0], 0); - Assert.AreEqual(loads[1], 1); - Assert.AreEqual(loads[2], 2); + ClassicAssert.AreEqual(loads[0], 0); + ClassicAssert.AreEqual(loads[1], 1); + ClassicAssert.AreEqual(loads[2], 2); - Assert.AreEqual(unloads[0], 2); - Assert.AreEqual(unloads[1], 0); - Assert.AreEqual(unloads[2], 1); + ClassicAssert.AreEqual(unloads[0], 2); + ClassicAssert.AreEqual(unloads[1], 0); + ClassicAssert.AreEqual(unloads[2], 1); } } @@ -418,11 +419,11 @@ public void TestSinglePage() { collection.Add("01234567890123456789012345678901234567890123456789"); var pages = collection.Pages.ToArray(); - Assert.AreEqual(1, pages.Length); - Assert.AreEqual(0, pages[0].StartIndex); - Assert.AreEqual(0, pages[0].EndIndex); - Assert.AreEqual(1, pages[0].Count); - Assert.AreEqual(100, pages[0].Size); + ClassicAssert.AreEqual(1, pages.Length); + ClassicAssert.AreEqual(0, pages[0].StartIndex); + ClassicAssert.AreEqual(0, pages[0].EndIndex); + ClassicAssert.AreEqual(1, pages[0].Count); + ClassicAssert.AreEqual(100, pages[0].Size); } } @@ -436,17 +437,17 @@ public void TestSinglePage2() { collection.Add("0123456789"); - Assert.AreEqual(5, collection.Count); + ClassicAssert.AreEqual(5, collection.Count); var pages = collection.Pages.ToArray(); - Assert.AreEqual(1, pages.Length); + ClassicAssert.AreEqual(1, pages.Length); // Page 0 - Assert.AreEqual(0, pages[0].Number); + ClassicAssert.AreEqual(0, pages[0].Number); - Assert.AreEqual(0, pages[0].StartIndex); - Assert.AreEqual(4, pages[0].EndIndex); - Assert.AreEqual(5, pages[0].Count); - Assert.AreEqual(100, pages[0].Size); + ClassicAssert.AreEqual(0, pages[0].StartIndex); + ClassicAssert.AreEqual(4, pages[0].EndIndex); + ClassicAssert.AreEqual(5, pages[0].Count); + ClassicAssert.AreEqual(100, pages[0].Size); } } @@ -461,29 +462,29 @@ public void TestTwoPages1() { collection.Add("01234567890123456789012345678901234567890123456789"); collection.Add("0123456789012345678901234567890123456789012345678"); - Assert.AreEqual(2, collection.Count); + ClassicAssert.AreEqual(2, collection.Count); var pages = collection.Pages.ToArray(); - Assert.AreEqual(2, pages.Length); + ClassicAssert.AreEqual(2, pages.Length); // Page 0 - Assert.AreEqual(0, pages[0].Number); - Assert.AreEqual(0, pages[0].StartIndex); - Assert.AreEqual(0, pages[0].EndIndex); - Assert.AreEqual(1, pages[0].Count); - Assert.AreEqual(100, pages[0].Size); + ClassicAssert.AreEqual(0, pages[0].Number); + ClassicAssert.AreEqual(0, pages[0].StartIndex); + ClassicAssert.AreEqual(0, pages[0].EndIndex); + ClassicAssert.AreEqual(1, pages[0].Count); + ClassicAssert.AreEqual(100, pages[0].Size); // Page 1 - Assert.AreEqual(1, pages[1].Number); - Assert.AreEqual(1, pages[1].StartIndex); - Assert.AreEqual(1, pages[1].EndIndex); - Assert.AreEqual(1, pages[1].Count); - Assert.AreEqual(98, pages[1].Size); + ClassicAssert.AreEqual(1, pages[1].Number); + ClassicAssert.AreEqual(1, pages[1].StartIndex); + ClassicAssert.AreEqual(1, pages[1].EndIndex); + ClassicAssert.AreEqual(1, pages[1].Count); + ClassicAssert.AreEqual(98, pages[1].Size); // Page Swaps - Assert.AreEqual(2, pageLoads.Count); - Assert.AreEqual(1, pageUnloads.Count); + ClassicAssert.AreEqual(2, pageLoads.Count); + ClassicAssert.AreEqual(1, pageUnloads.Count); - Assert.AreEqual(0, pageUnloads[0]); + ClassicAssert.AreEqual(0, pageUnloads[0]); } } @@ -505,37 +506,37 @@ public void TestTwoPages2() { collection.Add("0123456789"); collection.Add("012345678"); - Assert.AreEqual(10, collection.Count); + ClassicAssert.AreEqual(10, collection.Count); var pages = collection.Pages.ToArray(); - Assert.AreEqual(2, pages.Length); + ClassicAssert.AreEqual(2, pages.Length); // Page 0 - Assert.AreEqual(0, pages[0].Number); - Assert.AreEqual(0, pages[0].StartIndex); - Assert.AreEqual(4, pages[0].EndIndex); - Assert.AreEqual(5, pages[0].Count); - Assert.AreEqual(100, pages[0].Size); + ClassicAssert.AreEqual(0, pages[0].Number); + ClassicAssert.AreEqual(0, pages[0].StartIndex); + ClassicAssert.AreEqual(4, pages[0].EndIndex); + ClassicAssert.AreEqual(5, pages[0].Count); + ClassicAssert.AreEqual(100, pages[0].Size); // Page 1 - Assert.AreEqual(1, pages[1].Number); - Assert.AreEqual(5, pages[1].StartIndex); - Assert.AreEqual(9, pages[1].EndIndex); - Assert.AreEqual(5, pages[1].Count); - Assert.AreEqual(98, pages[1].Size); + ClassicAssert.AreEqual(1, pages[1].Number); + ClassicAssert.AreEqual(5, pages[1].StartIndex); + ClassicAssert.AreEqual(9, pages[1].EndIndex); + ClassicAssert.AreEqual(5, pages[1].Count); + ClassicAssert.AreEqual(98, pages[1].Size); // Page Swaps - Assert.AreEqual(2, pageLoads.Count); - Assert.AreEqual(1, pageUnloads.Count); - Assert.AreEqual(0, pageUnloads[0]); + ClassicAssert.AreEqual(2, pageLoads.Count); + ClassicAssert.AreEqual(1, pageUnloads.Count); + ClassicAssert.AreEqual(0, pageUnloads[0]); } } [Test] public void TestEmpty() { using (var collection = new MemoryPagedList(40, 1 * 40, str => str.Length * sizeof(char))) { - Assert.AreEqual(0, collection.Pages.Count()); - Assert.AreEqual(0, collection.Count); + ClassicAssert.AreEqual(0, collection.Pages.Count()); + ClassicAssert.AreEqual(0, collection.Count); } } @@ -545,8 +546,8 @@ public void TestEmptyItems() { collection.Add(""); collection.Add(""); collection.Add(""); - Assert.AreEqual(1, collection.Pages.Count()); - Assert.AreEqual(3, collection.Count); + ClassicAssert.AreEqual(1, collection.Pages.Count()); + ClassicAssert.AreEqual(3, collection.Count); } } @@ -571,7 +572,7 @@ public void TestIteratorThrowsWhenCollectionChanged_1() { } catch (Exception error) { thrown = true; } - Assert.IsTrue(thrown, "Exception was not thrown"); + ClassicAssert.IsTrue(thrown, "Exception was not thrown"); } } @@ -587,7 +588,7 @@ public void TestIteratorThrowsWhenCollectionChanged_2() { } catch (Exception error) { thrown = true; } - Assert.IsTrue(thrown, "Exception was not thrown"); + ClassicAssert.IsTrue(thrown, "Exception was not thrown"); } } @@ -607,9 +608,9 @@ public void TestIteratorThrowsWhenCollectionChanged_3() { foreach (var item in collection) { list.Add(item); } - Assert.AreEqual("10", list[0]); - Assert.AreEqual("20", list[1]); - Assert.AreEqual("30", list[2]); + ClassicAssert.AreEqual("10", list[0]); + ClassicAssert.AreEqual("20", list[1]); + ClassicAssert.AreEqual("30", list[2]); } } @@ -627,7 +628,7 @@ public void TestRandomAccess() { collection.Add(Tools.Text.GenerateRandomString(Tools.Maths.RNG.Next(0, 100))); } - Assert.AreEqual(10000, collection.Count); + ClassicAssert.AreEqual(10000, collection.Count); for (var i = 0; i < 300; i++) { var str = collection[Tools.Maths.RNG.Next(0, 10000 - 1)]; @@ -675,7 +676,7 @@ public void TestLinq() { .Reverse(); foreach (var val in testCollection) { - Assert.IsTrue(val.StartsWith("1") || val.StartsWith("2")); + ClassicAssert.IsTrue(val.StartsWith("1") || val.StartsWith("2")); } } diff --git a/tests/Hydrogen.Tests/Collections/Queue/ProducerConsumerQueueTest.cs b/tests/Hydrogen.Tests/Collections/Queue/ProducerConsumerQueueTest.cs index 93e731ab3..d41d6b899 100644 --- a/tests/Hydrogen.Tests/Collections/Queue/ProducerConsumerQueueTest.cs +++ b/tests/Hydrogen.Tests/Collections/Queue/ProducerConsumerQueueTest.cs @@ -11,6 +11,7 @@ using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -28,11 +29,11 @@ public class ProducerConsumerQueueTest { public async Task Simple() { using var queue = new ProducerConsumerQueue(10); await queue.PutAsync("Hello World!"); - Assert.AreEqual(1, queue.Count); + ClassicAssert.AreEqual(1, queue.Count); var r = await queue.TakeManyAsync(1); - Assert.AreEqual(0, queue.Count); - Assert.AreEqual(1, r.Length); - Assert.AreEqual("Hello World!", r[0]); + ClassicAssert.AreEqual(0, queue.Count); + ClassicAssert.AreEqual(1, r.Length); + ClassicAssert.AreEqual("Hello World!", r[0]); } [Test] @@ -86,7 +87,7 @@ async Task ConsumeTask() { await Task.WhenAll(ProduceTask(), ConsumeTask()); //Tools.NUnit.Print(result); - Assert.AreEqual(expected, result); + ClassicAssert.AreEqual(expected, result); } @@ -169,7 +170,7 @@ async Task ConsumeTask() { await Task.WhenAll(ProduceTask(), ConsumeTask()).WithTimeout(TimeSpan.FromSeconds(TimeoutSEC)); var resultArr = result.OrderBy(x => x).ToArray(); - Assert.AreEqual(expected, resultArr); + ClassicAssert.AreEqual(expected, resultArr); } diff --git a/tests/Hydrogen.Tests/Collections/Sets/BloomFilterTests.cs b/tests/Hydrogen.Tests/Collections/Sets/BloomFilterTests.cs index f5302ee0d..747ac5d7c 100644 --- a/tests/Hydrogen.Tests/Collections/Sets/BloomFilterTests.cs +++ b/tests/Hydrogen.Tests/Collections/Sets/BloomFilterTests.cs @@ -10,6 +10,7 @@ using System.Linq; using NUnit.Framework; using System.Text; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -29,7 +30,7 @@ public void Test_Consistency([Values(0.01, 0.05, 0.1, 0.5)] decimal targetError, var expected = filter.ToArray(); for (var i = 0; i < 5; i++) { filter.Add(data); - Assert.AreEqual(expected, filter.ToArray()); // same data doesnt change filter + ClassicAssert.AreEqual(expected, filter.ToArray()); // same data doesnt change filter } } @@ -43,7 +44,7 @@ public void Test_FalseNegatives([Values(0.01, 0.05, 0.1, 0.5)] decimal targetErr for (var i = 0; i < maxExpectedItems; i++) { var data = RNG.NextString(10, 50); filter.Add(data); - Assert.IsTrue(filter.Contains(data)); + ClassicAssert.IsTrue(filter.Contains(data)); } } @@ -59,19 +60,19 @@ public void IntegrationTest([Values(0.01, 0.05, 0.1, 0.5)] decimal targetError, var data = Tools.Collection.Generate(() => RNG.NextString(10, 50)).Take(maxExpectedItems).ToArray(); foreach (var datum in data) { filter.Add(datum); - Assert.IsTrue(filter.Contains(datum)); + ClassicAssert.IsTrue(filter.Contains(datum)); } // No false negatives var falseNegatives = data.Count(x => !filter.Contains(x)); - Assert.AreEqual(0, falseNegatives); + ClassicAssert.AreEqual(0, falseNegatives); // False positive error rate is tolerable var diffData = Enumerable.Range(0, int.MaxValue).Zip(data.Loop(), (i, s) => $"__{i}_{s}").Take(FalsePositiveSampleSize).ToArray(); var falsePositives = diffData.Count(filter.Contains); var actualError = falsePositives / (decimal)diffData.Length; var errorUpperBound = targetError + 0.07M; // allow 7% tolerance for testing (happens when filter is small) - Assert.LessOrEqual(actualError, errorUpperBound); + ClassicAssert.LessOrEqual(actualError, errorUpperBound); } diff --git a/tests/Hydrogen.Tests/Collections/Sets/ReferenceHashSetTests.cs b/tests/Hydrogen.Tests/Collections/Sets/ReferenceHashSetTests.cs index 1bb84733e..85082af59 100644 --- a/tests/Hydrogen.Tests/Collections/Sets/ReferenceHashSetTests.cs +++ b/tests/Hydrogen.Tests/Collections/Sets/ReferenceHashSetTests.cs @@ -9,6 +9,7 @@ using System.Collections.Generic; using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -24,7 +25,7 @@ public void Test_Add() { referenceHashSet.Add(key2); Assert.That(referenceHashSet.Count, Is.EqualTo(2)); Assert.That(referenceHashSet.Contains("one"), Is.True); - CollectionAssert.AreEqual(referenceHashSet.ToArray(), new [] { key1, key2 }); + ClassicAssert.AreEqual(referenceHashSet.ToArray(), new [] { key1, key2 }); } [Test] @@ -35,7 +36,7 @@ public void Test_Remove() { referenceHashSet.Add(key1); referenceHashSet.Add(key2); referenceHashSet.Remove("one"); // remove key1 value since compiler re-uses string literals - CollectionAssert.AreEqual(referenceHashSet.ToArray(), new [] { key2 }); + ClassicAssert.AreEqual(referenceHashSet.ToArray(), new [] { key2 }); } } diff --git a/tests/Hydrogen.Tests/Collections/StreamMapped/StreamMappedListTests.cs b/tests/Hydrogen.Tests/Collections/StreamMapped/StreamMappedListTests.cs index 3014174ab..3092c353c 100644 --- a/tests/Hydrogen.Tests/Collections/StreamMapped/StreamMappedListTests.cs +++ b/tests/Hydrogen.Tests/Collections/StreamMapped/StreamMappedListTests.cs @@ -14,6 +14,7 @@ using NUnit.Framework; using Hydrogen.NUnit; using Microsoft.CodeAnalysis.CSharp.Syntax; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -81,9 +82,9 @@ public void ReadRange([ClusteredStreamsPolicyTestValues] ClusteredStreamsPolicy .ReadRange(0, 3) .ToArray(); - Assert.AreEqual(inputs[0], read[0]); - Assert.AreEqual(inputs[1], read[1]); - Assert.AreEqual(inputs[2], read[2]); + ClassicAssert.AreEqual(inputs[0], read[0]); + ClassicAssert.AreEqual(inputs[1], read[1]); + ClassicAssert.AreEqual(inputs[2], read[2]); } [Test] @@ -108,10 +109,10 @@ public void ReadRangeEmpty([ClusteredStreamsPolicyTestValues] ClusteredStreamsPo list.Load(); list.AddRange(999, 1000, 1001, 1002); - Assert.IsEmpty(list.ReadRange(0, 0)); + ClassicAssert.IsEmpty(list.ReadRange(0, 0)); list.Clear(); - Assert.IsEmpty(list.ReadRange(0, 0)); + ClassicAssert.IsEmpty(list.ReadRange(0, 0)); } [Test] @@ -165,8 +166,8 @@ public void UpdateRange([ClusteredStreamsPolicyTestValues] ClusteredStreamsPolic string update = random.NextString(0, 100); list.UpdateRange(0, new[] { update }); var value = list.Read(0); - Assert.AreEqual(update, value); - Assert.AreEqual(inputs.Length, list.Count); + ClassicAssert.AreEqual(update, value); + ClassicAssert.AreEqual(inputs.Length, list.Count); } [Test] @@ -180,8 +181,8 @@ public void UpdateRangeInvalidArguments([ClusteredStreamsPolicyTestValues] Clust list.UpdateRange(0, new[] { 998 }); int read = list[0]; - Assert.AreEqual(998, read); - Assert.AreEqual(4, list.Count); + ClassicAssert.AreEqual(998, read); + ClassicAssert.AreEqual(4, list.Count); } [Test] @@ -196,8 +197,8 @@ public void RemoveRange([ClusteredStreamsPolicyTestValues] ClusteredStreamsPolic list.AddRange(inputs); list.RemoveRange(0, 1); - Assert.AreEqual(inputs[1], list[0]); - Assert.AreEqual(inputs.Length - 1, list.Count); + ClassicAssert.AreEqual(inputs[1], list[0]); + ClassicAssert.AreEqual(inputs.Length - 1, list.Count); } [Test] @@ -228,7 +229,7 @@ public void IndexOf([ClusteredStreamsPolicyTestValues] ClusteredStreamsPolicy po IEnumerable indexes = list.IndexOfRange(inputs[..5]); - Assert.AreEqual(new[] { 0, 1, 2, 3, 4 }, indexes); + ClassicAssert.AreEqual(new[] { 0, 1, 2, 3, 4 }, indexes); } [Test] @@ -262,10 +263,10 @@ public void Count([ClusteredStreamsPolicyTestValues] ClusteredStreamsPolicy poli using var list = StreamMappedFactory.CreateList(stream, 32, new StringSerializer(Encoding.UTF8), itemChecksummer: useChecksumIndex ? new ObjectHashCodeChecksummer() : null, reservedStreams: useChecksumIndex ? 1 : 0, policy: policy); if (list.RequiresLoad) list.Load(); - Assert.AreEqual(0, list.Count); + ClassicAssert.AreEqual(0, list.Count); list.AddRange(inputs); - Assert.AreEqual(inputs.Length, list.Count); + ClassicAssert.AreEqual(inputs.Length, list.Count); } [Test] @@ -280,8 +281,8 @@ public void InsertRange([ClusteredStreamsPolicyTestValues] ClusteredStreamsPolic list.AddRange(inputs); list.InsertRange(0, new[] { random.NextString(1, 100) }); - Assert.AreEqual(inputs.Length + 1, list.Count); - Assert.AreEqual(inputs[0], list[1]); + ClassicAssert.AreEqual(inputs.Length + 1, list.Count); + ClassicAssert.AreEqual(inputs[0], list[1]); } [Test] @@ -309,10 +310,10 @@ public void Clear([ClusteredStreamsPolicyTestValues] ClusteredStreamsPolicy poli list.Load(); list.AddRange(inputs); list.Clear(); - Assert.AreEqual(0, list.Count); + ClassicAssert.AreEqual(0, list.Count); list.AddRange(inputs); - Assert.AreEqual(inputs, list); + ClassicAssert.AreEqual(inputs, list); } [Test] @@ -346,14 +347,14 @@ public void LoadAndUseExistingStream([Values(1, 100)] int iterations, [Clustered using var list = StreamMappedFactory.CreateList(fileStream, 32, new StringSerializer(Encoding.UTF8), itemChecksummer: useChecksumIndex ? new ObjectHashCodeChecksummer() : null, reservedStreams: useChecksumIndex ? 1 : 0, policy: policy); if (list.RequiresLoad) list.Load(); - Assert.AreEqual(input.Length, list.Count); - Assert.AreEqual(input, list); + ClassicAssert.AreEqual(input.Length, list.Count); + ClassicAssert.AreEqual(input, list); var secondInput = Enumerable.Range(0, random.Next(1, 100)).Select(x => random.NextString(1, 100)).ToArray(); list.AddRange(secondInput); - Assert.AreEqual(input.Concat(secondInput), list.ReadRange(0, list.Count)); + ClassicAssert.AreEqual(input.Concat(secondInput), list.ReadRange(0, list.Count)); list.RemoveRange(0, list.Count); - Assert.IsEmpty(list); + ClassicAssert.IsEmpty(list); } } } diff --git a/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleDictionaryCLKTests.cs b/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleDictionaryCLKTests.cs index d188a9307..3641ebd3d 100644 --- a/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleDictionaryCLKTests.cs +++ b/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleDictionaryCLKTests.cs @@ -97,7 +97,7 @@ public void DynamicKey_StaticKey_ConsistencyTest([Values(CHF.SHA2_256, CHF.Blake endOfIterTest: () => { //var clkLeafs = clk.MerkleTree.GetLeafs().ToArray(); //var kvpLeafs = kvp.MerkleTree.GetLeafs().ToArray(); - //CollectionAssert.AreEqual(clkLeafs, kvpLeafs); + //ClassicAssert.AreEqual(clkLeafs, kvpLeafs); Assert.That(clk.MerkleTree.Root, Is.EqualTo(kvp.MerkleTree.Root)); }, expected: kvp diff --git a/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleDictionaryTestsBase.cs b/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleDictionaryTestsBase.cs index 189601267..7a6922011 100644 --- a/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleDictionaryTestsBase.cs +++ b/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleDictionaryTestsBase.cs @@ -11,6 +11,7 @@ using System.Linq; using NUnit.Framework; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -322,7 +323,7 @@ public void IntegrationTests([Values(CHF.SHA2_256, CHF.Blake2b_128)] CHF chf) { return Hashers.JoinHash(chf, keyHash, valueHash); }).ToArray(); var treeLeaves = clusteredDictionary.MerkleTree.GetLeafs().ToArray(); - CollectionAssert.AreEqual(itemHashes, treeLeaves); + ClassicAssert.AreEqual(itemHashes, treeLeaves); Assert.That(clusteredDictionary.MerkleTree.Root, Is.EqualTo(MerkleTree.ComputeMerkleRoot(itemHashes, chf))); } ); diff --git a/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleRecyclableListTests.cs b/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleRecyclableListTests.cs index 3ed77eaf2..3c865eff8 100644 --- a/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleRecyclableListTests.cs +++ b/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedMerkleRecyclableListTests.cs @@ -12,6 +12,7 @@ using System.Linq; using FastSerialization; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -55,7 +56,7 @@ public void WalkThrough_CheckMerkleTree([Values(CHF.SHA2_256, CHF.Blake2b_128)] Assert.That(list.MerkleTree.Root, Is.Null); // Enumerate empty - CollectionAssert.AreEqual(list, Array.Empty()); + ClassicAssert.AreEqual(list, Array.Empty()); // add "A" list.Add("A"); @@ -90,7 +91,7 @@ public void WalkThrough_CheckMerkleTree([Values(CHF.SHA2_256, CHF.Blake2b_128)] Assert.That(() => list.RemoveAt(1), Throws.ArgumentException); // Enumerate - CollectionAssert.AreEqual(list, new[] { "A", "C" }); + ClassicAssert.AreEqual(list, new[] { "A", "C" }); Assert.That(list.Count, Is.EqualTo(2)); Assert.That(list.ListCount, Is.EqualTo(3)); Assert.That(list.RecycledCount, Is.EqualTo(1)); @@ -115,7 +116,7 @@ public void WalkThrough_CheckMerkleTree([Values(CHF.SHA2_256, CHF.Blake2b_128)] Assert.That(list.MerkleTree.Root, Is.EqualTo(TreeHash("A", "B2", "C"))); // Enumeration check - CollectionAssert.AreEqual(list, new[] { "A", "B2", "C" }); + ClassicAssert.AreEqual(list, new[] { "A", "B2", "C" }); // add another "A" (verify used new index) list.Add("A"); @@ -160,7 +161,7 @@ public void WalkThrough_CheckMerkleTree([Values(CHF.SHA2_256, CHF.Blake2b_128)] Assert.That(list.IndexOf("C"), Is.EqualTo(2)); // Enumerate "B2" and "C" - CollectionAssert.AreEqual(list, new[] { "B2", "C" }); + ClassicAssert.AreEqual(list, new[] { "B2", "C" }); // Clear list.Clear(); diff --git a/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedRecyclableListWithIndexTests.cs b/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedRecyclableListWithIndexTests.cs index b6cb10804..8ca95a168 100644 --- a/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedRecyclableListWithIndexTests.cs +++ b/tests/Hydrogen.Tests/Collections/StreamMappedMerkle/StreamMappedRecyclableListWithIndexTests.cs @@ -3,6 +3,7 @@ using System.IO; using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -42,7 +43,7 @@ public void WalkThrough_CheckMerkleTree() { Assert.That(mlist.MerkleTree.Root, Is.Null); // Enumerate empty - CollectionAssert.AreEqual(rlist, Array.Empty()); + ClassicAssert.AreEqual(rlist, Array.Empty()); // add "A" rlist.Add("A"); @@ -77,7 +78,7 @@ public void WalkThrough_CheckMerkleTree() { Assert.That(() => rlist.RemoveAt(1), Throws.ArgumentException); // Enumerate - CollectionAssert.AreEqual(rlist, new[] { "A", "C" }); + ClassicAssert.AreEqual(rlist, new[] { "A", "C" }); Assert.That(rlist.Count, Is.EqualTo(2)); Assert.That(rlist.ListCount, Is.EqualTo(3)); Assert.That(rlist.RecycledCount, Is.EqualTo(1)); @@ -102,7 +103,7 @@ public void WalkThrough_CheckMerkleTree() { Assert.That(mlist.MerkleTree.Root, Is.EqualTo(TreeHash("A", "B2", "C"))); // Enumeration check - CollectionAssert.AreEqual(rlist, new[] { "A", "B2", "C" }); + ClassicAssert.AreEqual(rlist, new[] { "A", "B2", "C" }); // add another "A" (verify used new index) rlist.Add("A"); @@ -147,7 +148,7 @@ public void WalkThrough_CheckMerkleTree() { Assert.That(rlist.IndexOf("C"), Is.EqualTo(2)); // Enumerate "B2" and "C" - CollectionAssert.AreEqual(rlist, new[] { "B2", "C" }); + ClassicAssert.AreEqual(rlist, new[] { "B2", "C" }); // Clear rlist.Clear(); diff --git a/tests/Hydrogen.Tests/Collections/StreamPaged/StreamPagedListTests.cs b/tests/Hydrogen.Tests/Collections/StreamPaged/StreamPagedListTests.cs index 74c2f3fb7..d57080c7c 100644 --- a/tests/Hydrogen.Tests/Collections/StreamPaged/StreamPagedListTests.cs +++ b/tests/Hydrogen.Tests/Collections/StreamPaged/StreamPagedListTests.cs @@ -12,6 +12,7 @@ using NUnit.Framework; using System.IO; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -29,7 +30,7 @@ public void EmptyString_Bug() { var size = serializer.ConstantSize; var list = new StreamPagedList(serializer, clusteredStream, includeListHeader: false, autoLoad: true); list.Add(""); - Assert.AreEqual(1, list.Count); + ClassicAssert.AreEqual(1, list.Count); var item = list.Read(0); Assert.That(item, Is.EqualTo(string.Empty)); } @@ -40,7 +41,7 @@ public void Add_1([Values(1, 111)] int pageSize) { var list = new StreamPagedList(new StringSerializer(Encoding.UTF8), stream, pageSize); list.Add("item1"); - Assert.AreEqual(1, list.Count); + ClassicAssert.AreEqual(1, list.Count); } [Test] @@ -51,7 +52,7 @@ public void Update_1([Values(1, 111)] int pageSize) { list.Add("item1"); list.Update(0, "item2"); - Assert.AreEqual("item2", list[0]); + ClassicAssert.AreEqual("item2", list[0]); } [Test] @@ -61,7 +62,7 @@ public void Add_2([Values(1, 2, 111)] int pageSize) { list.Add("item1"); list.Add("the second item"); - Assert.AreEqual(2, list.Count); + ClassicAssert.AreEqual(2, list.Count); } [Test] @@ -71,7 +72,7 @@ public void Add_3([Values(1, 2, 111)] int pageSize) { list.Add("item1"); list.AddRange("the second item", "33333333333333333333333333"); - Assert.AreEqual(3, list.Count); + ClassicAssert.AreEqual(3, list.Count); } [Test] @@ -80,7 +81,7 @@ public void Read_1([Values(1, 2)] int pageSize) { var list = new StreamPagedList(new StringSerializer(Encoding.UTF8), stream, pageSize); list.Add("item1"); - Assert.AreEqual("item1", list[0]); + ClassicAssert.AreEqual("item1", list[0]); } [Test] @@ -89,8 +90,8 @@ public void Read_2([Values(1, 2)] int pageSize) { var list = new StreamPagedList(new StringSerializer(Encoding.UTF8), stream, pageSize); list.AddRange("item1", "item2"); - Assert.AreEqual("item1", list[0]); - Assert.AreEqual("item2", list[1]); + ClassicAssert.AreEqual("item1", list[0]); + ClassicAssert.AreEqual("item2", list[1]); } [Test] @@ -101,7 +102,7 @@ public void FixedSize_Read_NoHeader() { var added = new[] { 1, 2, 3, 4 }; list.AddRange(added); var read = list.ReadRange(2, 2); - Assert.AreEqual(added[2..], read); + ClassicAssert.AreEqual(added[2..], read); } [Test] @@ -114,7 +115,7 @@ public void FixedSize_Update() { list.UpdateRange(0, read); - Assert.AreEqual(added, list); + ClassicAssert.AreEqual(added, list); } [Test] @@ -128,9 +129,9 @@ public void ReadItemRaw(StreamPagedListType type, int pageSize) { mappedList.AddRange(random.NextInts(10)); int read = mappedList.ReadItemBytes(1, 1, 3, out var span); - Assert.AreEqual(read, span.Length); - Assert.AreEqual(3, span.Length); - Assert.AreEqual(BitConverter.GetBytes(mappedList[1])[1..], span.ToArray()); + ClassicAssert.AreEqual(read, span.Length); + ClassicAssert.AreEqual(3, span.Length); + ClassicAssert.AreEqual(BitConverter.GetBytes(mappedList[1])[1..], span.ToArray()); } [Test] @@ -153,23 +154,23 @@ public void V1_Integration_SimpleRun([Values(1, 2, 3, 5)] int pageSize, [Values] var len0 = stream.Length; list.Add("test"); - Assert.AreEqual(1, list.Count); - Assert.AreEqual("test", list[0]); + ClassicAssert.AreEqual(1, list.Count); + ClassicAssert.AreEqual("test", list[0]); var len1 = stream.Length; list.Add("test2"); - Assert.AreEqual(2, list.Count); - Assert.AreEqual("test", list[0]); - Assert.AreEqual("test2", list[1]); + ClassicAssert.AreEqual(2, list.Count); + ClassicAssert.AreEqual("test", list[0]); + ClassicAssert.AreEqual("test2", list[1]); var len2 = stream.Length; list.Add("test33"); - Assert.AreEqual(3, list.Count); - Assert.AreEqual("test", list[0]); - Assert.AreEqual("test33", list[2]); - Assert.AreEqual("test2", list[1]); + ClassicAssert.AreEqual(3, list.Count); + ClassicAssert.AreEqual("test", list[0]); + ClassicAssert.AreEqual("test33", list[2]); + ClassicAssert.AreEqual("test2", list[1]); var len3 = stream.Length; @@ -179,26 +180,26 @@ public void V1_Integration_SimpleRun([Values(1, 2, 3, 5)] int pageSize, [Values] // Remove tip list.RemoveAt(2); - Assert.AreEqual(2, list.Count); - Assert.AreEqual("test", list[0]); - Assert.AreEqual("test2", list[1]); + ClassicAssert.AreEqual(2, list.Count); + ClassicAssert.AreEqual("test", list[0]); + ClassicAssert.AreEqual("test2", list[1]); - Assert.AreEqual(len2, stream.Length); + ClassicAssert.AreEqual(len2, stream.Length); // Illegal remove Assert.That(() => list.RemoveAt(0), Throws.Exception); // Remove rest list.RemoveAt(1); - Assert.AreEqual(1, list.Count); - Assert.AreEqual("test", list[0]); + ClassicAssert.AreEqual(1, list.Count); + ClassicAssert.AreEqual("test", list[0]); - Assert.AreEqual(len1, stream.Length); + ClassicAssert.AreEqual(len1, stream.Length); list.RemoveAt(0); - Assert.AreEqual(0, list.Count); + ClassicAssert.AreEqual(0, list.Count); - Assert.AreEqual(len0, stream.Length); + ClassicAssert.AreEqual(len0, stream.Length); } } diff --git a/tests/Hydrogen.Tests/Collections/Transactional/FileTransactionScopeTests.cs b/tests/Hydrogen.Tests/Collections/Transactional/FileTransactionScopeTests.cs index e922cead9..48aead2d0 100644 --- a/tests/Hydrogen.Tests/Collections/Transactional/FileTransactionScopeTests.cs +++ b/tests/Hydrogen.Tests/Collections/Transactional/FileTransactionScopeTests.cs @@ -11,6 +11,7 @@ using NUnit.Framework; using System.IO; using System.Threading.Tasks; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -42,19 +43,19 @@ public void EnlistedFilesAggregateInNestedScopes() { scope3.EnlistFile(filePath3, 100, 1 * 100); // Ensures that scope3 refers to 3 enlisted files - Assert.AreEqual(filePath1, scope3.Transaction.EnlistedFiles[0].FileDescriptor.CaseCorrectPath); - Assert.AreEqual(filePath2, scope3.Transaction.EnlistedFiles[1].FileDescriptor.CaseCorrectPath); - Assert.AreEqual(filePath3, scope3.Transaction.EnlistedFiles[2].FileDescriptor.CaseCorrectPath); + ClassicAssert.AreEqual(filePath1, scope3.Transaction.EnlistedFiles[0].FileDescriptor.CaseCorrectPath); + ClassicAssert.AreEqual(filePath2, scope3.Transaction.EnlistedFiles[1].FileDescriptor.CaseCorrectPath); + ClassicAssert.AreEqual(filePath3, scope3.Transaction.EnlistedFiles[2].FileDescriptor.CaseCorrectPath); } // Ensures that scope3 refers to 3 enlisted files - Assert.AreEqual(filePath1, scope2.Transaction.EnlistedFiles[0].FileDescriptor.CaseCorrectPath); - Assert.AreEqual(filePath2, scope2.Transaction.EnlistedFiles[1].FileDescriptor.CaseCorrectPath); - Assert.AreEqual(filePath3, scope2.Transaction.EnlistedFiles[2].FileDescriptor.CaseCorrectPath); + ClassicAssert.AreEqual(filePath1, scope2.Transaction.EnlistedFiles[0].FileDescriptor.CaseCorrectPath); + ClassicAssert.AreEqual(filePath2, scope2.Transaction.EnlistedFiles[1].FileDescriptor.CaseCorrectPath); + ClassicAssert.AreEqual(filePath3, scope2.Transaction.EnlistedFiles[2].FileDescriptor.CaseCorrectPath); } // Ensures that scope3 refers to 3 enlisted files - Assert.AreEqual(filePath1, scope1.Transaction.EnlistedFiles[0].FileDescriptor.CaseCorrectPath); - Assert.AreEqual(filePath2, scope1.Transaction.EnlistedFiles[1].FileDescriptor.CaseCorrectPath); - Assert.AreEqual(filePath3, scope1.Transaction.EnlistedFiles[2].FileDescriptor.CaseCorrectPath); + ClassicAssert.AreEqual(filePath1, scope1.Transaction.EnlistedFiles[0].FileDescriptor.CaseCorrectPath); + ClassicAssert.AreEqual(filePath2, scope1.Transaction.EnlistedFiles[1].FileDescriptor.CaseCorrectPath); + ClassicAssert.AreEqual(filePath3, scope1.Transaction.EnlistedFiles[2].FileDescriptor.CaseCorrectPath); } } } @@ -135,11 +136,11 @@ public void Nested_CommitCommit() { using (var scope2 = new FileTransactionScope(txnBaseDir)) { // child scope should get absorb parent transaction automatically - Assert.AreEqual(scope1.Transaction, scope2.Transaction); - Assert.AreEqual(scope1.TransactionFile, scope2.TransactionFile); + ClassicAssert.AreEqual(scope1.Transaction, scope2.Transaction); + ClassicAssert.AreEqual(scope1.TransactionFile, scope2.TransactionFile); // Should have enlisted file - Assert.AreEqual(file, scope2.Transaction.EnlistedFiles[0]); + ClassicAssert.AreEqual(file, scope2.Transaction.EnlistedFiles[0]); scope2.Transaction.EnlistedFiles[0].AddRange(chunk2); // child commit doesn't commit @@ -152,10 +153,10 @@ public void Nested_CommitCommit() { scope1.Commit(); } - Assert.AreEqual(original.Concat(chunk1).Concat(chunk2).Concat(chunk3), File.ReadAllBytes(filePath)); + ClassicAssert.AreEqual(original.Concat(chunk1).Concat(chunk2).Concat(chunk3), File.ReadAllBytes(filePath)); } // check no transaction files - Assert.IsTrue(!File.Exists(txnFile)); + ClassicAssert.IsTrue(!File.Exists(txnFile)); } [Test] @@ -181,10 +182,10 @@ public void Nested_CommitRollback() { using (var scope2 = new FileTransactionScope(txnBaseDir)) { // child scope should get absorb parent transaction automatically - Assert.AreEqual(scope1.Transaction, scope2.Transaction); + ClassicAssert.AreEqual(scope1.Transaction, scope2.Transaction); // Should have enlisted file - Assert.AreEqual(file, scope2.Transaction.EnlistedFiles[0]); + ClassicAssert.AreEqual(file, scope2.Transaction.EnlistedFiles[0]); scope2.Transaction.EnlistedFiles[0].AddRange(chunk2); // child commit doesn't commit @@ -197,10 +198,10 @@ public void Nested_CommitRollback() { scope1.Commit(); } - Assert.AreEqual(original, File.ReadAllBytes(filePath)); + ClassicAssert.AreEqual(original, File.ReadAllBytes(filePath)); // check no transaction files - Assert.IsTrue(!File.Exists(txnFile)); + ClassicAssert.IsTrue(!File.Exists(txnFile)); } } @@ -228,16 +229,16 @@ public void Nested_RollbackCommit() { using (var scope2 = new FileTransactionScope(txnBaseDir)) { // child scope should get absorb parent transaction automatically - Assert.AreEqual(scope1.Transaction, scope2.Transaction); + ClassicAssert.AreEqual(scope1.Transaction, scope2.Transaction); // Should have enlisted file - Assert.AreEqual(file, scope2.Transaction.EnlistedFiles[0]); + ClassicAssert.AreEqual(file, scope2.Transaction.EnlistedFiles[0]); scope2.Transaction.EnlistedFiles[0].AddRange(chunk2); // child commit doesn't commit scope2.Commit(); // check no transaction files - Assert.IsTrue(File.Exists(txnFile)); + ClassicAssert.IsTrue(File.Exists(txnFile)); } // Add a third chunk @@ -245,10 +246,10 @@ public void Nested_RollbackCommit() { scope1.Rollback(); } - Assert.AreEqual(original, File.ReadAllBytes(filePath)); + ClassicAssert.AreEqual(original, File.ReadAllBytes(filePath)); // check no transaction files - Assert.IsTrue(!File.Exists(txnFile)); + ClassicAssert.IsTrue(!File.Exists(txnFile)); } } @@ -277,10 +278,10 @@ public void Nested_RollbackRollback() { using (var scope2 = new FileTransactionScope(txnBaseDir)) { // child scope should get absorb parent transaction automatically - Assert.AreEqual(scope1.Transaction, scope2.Transaction); + ClassicAssert.AreEqual(scope1.Transaction, scope2.Transaction); // Should have enlisted file - Assert.AreEqual(file, scope2.Transaction.EnlistedFiles[0]); + ClassicAssert.AreEqual(file, scope2.Transaction.EnlistedFiles[0]); scope2.Transaction.EnlistedFiles[0].AddRange(chunk2); // child commit doesn't commit @@ -292,10 +293,10 @@ public void Nested_RollbackRollback() { scope1.Rollback(); } - Assert.AreEqual(original, File.ReadAllBytes(filePath)); + ClassicAssert.AreEqual(original, File.ReadAllBytes(filePath)); // check no transaction files - Assert.IsTrue(!File.Exists(txnFile)); + ClassicAssert.IsTrue(!File.Exists(txnFile)); } } diff --git a/tests/Hydrogen.Tests/Collections/Transactional/FileTransactionTests.cs b/tests/Hydrogen.Tests/Collections/Transactional/FileTransactionTests.cs index fbcaa93fd..28382036b 100644 --- a/tests/Hydrogen.Tests/Collections/Transactional/FileTransactionTests.cs +++ b/tests/Hydrogen.Tests/Collections/Transactional/FileTransactionTests.cs @@ -11,6 +11,7 @@ using System.Linq; using NUnit.Framework; using System.IO; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -39,11 +40,11 @@ public void Sequential_CommitCommit() { file.AddRange(chunk1); transaction.Commit(); // check no transaction files - Assert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); + ClassicAssert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); file.AddRange(chunk2); transaction.Commit(); } - Assert.AreEqual(original.Concat(chunk1).Concat(chunk2), File.ReadAllBytes(filePath)); + ClassicAssert.AreEqual(original.Concat(chunk1).Concat(chunk2), File.ReadAllBytes(filePath)); } } @@ -68,11 +69,11 @@ public void Sequential_CommitRollback() { file.AddRange(chunk1); transaction.Commit(); // check no transaction files - Assert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); + ClassicAssert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); file.AddRange(chunk2); transaction.Rollback(); } - Assert.AreEqual(original.Concat(chunk1), File.ReadAllBytes(filePath)); + ClassicAssert.AreEqual(original.Concat(chunk1), File.ReadAllBytes(filePath)); } } @@ -98,11 +99,11 @@ public void Sequential_RollbackCommit() { file.AddRange(chunk1); transaction.Rollback(); // check no transaction files - Assert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); + ClassicAssert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); file.AddRange(chunk2); transaction.Commit(); } - Assert.AreEqual(original.Concat(chunk2), File.ReadAllBytes(filePath)); + ClassicAssert.AreEqual(original.Concat(chunk2), File.ReadAllBytes(filePath)); } } @@ -128,11 +129,11 @@ public void Sequential_RollbackRollback() { file.AddRange(chunk1); transaction.Rollback(); // check no transaction files - Assert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); + ClassicAssert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); file.AddRange(chunk2); transaction.Rollback(); } - Assert.AreEqual(original, File.ReadAllBytes(filePath)); + ClassicAssert.AreEqual(original, File.ReadAllBytes(filePath)); } } @@ -222,12 +223,12 @@ public void Integration_Commit([Values(1, 2, 7, 11)] int numFiles) { } // check no transaction junk - Assert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); + ClassicAssert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); // check files match expected for (var i = 0; i < numFiles; i++) { var filename = Path.Combine(fileBaseDir, $"File{i}.dat"); - Assert.AreEqual(expected[i], File.ReadAllBytes(filename)); + ClassicAssert.AreEqual(expected[i], File.ReadAllBytes(filename)); } } } @@ -296,18 +297,18 @@ public void Integration_ResumeCommit([Values(1, 2, 7, 11)] int numFiles) { // Reload transaction file should resume prior commit using (var transaction = new FileTransaction(txnFile, txnBaseDir)) { // Checks transaction is empty and usable (resumption was done in constructor) - Assert.AreEqual(FileTransactionState.Unchanged, transaction.Status); - Assert.IsEmpty(transaction.EnlistedFiles); + ClassicAssert.AreEqual(FileTransactionState.Unchanged, transaction.Status); + ClassicAssert.IsEmpty(transaction.EnlistedFiles); } // check no transaction junk - Assert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); + ClassicAssert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); // check files match expected for (var i = 0; i < numFiles; i++) { var filename = Path.Combine(fileBaseDir, $"File{i}.dat"); var fileData = File.ReadAllBytes(filename); - Assert.AreEqual(expected[i], fileData); + ClassicAssert.AreEqual(expected[i], fileData); } } } @@ -365,12 +366,12 @@ public void Integration_Rollback([Values(1, 2, 7, 11)] int numFiles) { } // check no transaction junk - Assert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); + ClassicAssert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); // check files match expected for (var i = 0; i < numFiles; i++) { var filename = Path.Combine(fileBaseDir, $"File{i}.dat"); - Assert.AreEqual(original[i], File.ReadAllBytes(filename)); + ClassicAssert.AreEqual(original[i], File.ReadAllBytes(filename)); } } } @@ -443,18 +444,18 @@ public void Integration_ResumeRollback([Values(1, 2, 7, 11)] int numFiles) { // Reload transaction file should resume prior rollback using (var transaction = new FileTransaction(txnFile, txnBaseDir)) { // Checks transaction is empty and usable (resumption was done in constructor) - Assert.AreEqual(FileTransactionState.Unchanged, transaction.Status); - Assert.IsEmpty(transaction.EnlistedFiles); + ClassicAssert.AreEqual(FileTransactionState.Unchanged, transaction.Status); + ClassicAssert.IsEmpty(transaction.EnlistedFiles); } // check no transaction junk - Assert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); + ClassicAssert.AreEqual(0, Tools.FileSystem.GetFiles(txnBaseDir).Count()); // check files are unchanged for (var i = 0; i < numFiles; i++) { var filename = Path.Combine(fileBaseDir, $"File{i}.dat"); var fileData = File.ReadAllBytes(filename); - Assert.AreEqual(original[i], fileData); + ClassicAssert.AreEqual(original[i], fileData); } } } diff --git a/tests/Hydrogen.Tests/Collections/Transactional/TransactionalFileMappedBufferTests.cs b/tests/Hydrogen.Tests/Collections/Transactional/TransactionalFileMappedBufferTests.cs index d2bbe4635..167541564 100644 --- a/tests/Hydrogen.Tests/Collections/Transactional/TransactionalFileMappedBufferTests.cs +++ b/tests/Hydrogen.Tests/Collections/Transactional/TransactionalFileMappedBufferTests.cs @@ -11,6 +11,7 @@ using System.Linq; using NUnit.Framework; using System.IO; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -20,21 +21,21 @@ public class TransactionalFileMappedBufferTests { private const int RandomSeed = 123292; private static void AssertEmptyDir(string dir) { - Assert.IsTrue(Directory.Exists(dir)); - Assert.AreEqual(0, Directory.GetFiles(dir).Length); + ClassicAssert.IsTrue(Directory.Exists(dir)); + ClassicAssert.AreEqual(0, Directory.GetFiles(dir).Length); } private static void AssertSingleFile(string dir, string filename) { - Assert.IsTrue(Directory.Exists(dir)); + ClassicAssert.IsTrue(Directory.Exists(dir)); var files = Directory.GetFiles(dir); - Assert.AreEqual(1, files.Length); - Assert.AreEqual(Path.GetFileName(filename), Path.GetFileName(files[0])); + ClassicAssert.AreEqual(1, files.Length); + ClassicAssert.AreEqual(Path.GetFileName(filename), Path.GetFileName(files[0])); } private static void AssertFileCount(string dir, int expectedCount) { - Assert.IsTrue(Directory.Exists(dir)); + ClassicAssert.IsTrue(Directory.Exists(dir)); var files = Directory.GetFiles(dir); - Assert.AreEqual(expectedCount, files.Length); + ClassicAssert.AreEqual(expectedCount, files.Length); } #region Single Page @@ -60,7 +61,7 @@ public void ExistingFile_EditSinglePage_InMemoryUpdateOnly([Values(1, 17, 7173)] var pageFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(baseDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.UncommittedPage, 0); // Check pagefile for page 0 doesn't exist yet - Assert.IsTrue(!File.Exists(pageFile)); + ClassicAssert.IsTrue(!File.Exists(pageFile)); } } } @@ -90,7 +91,7 @@ public void ExistingFile_EditSinglePage_UncommittedPageCreated([Values(1, 17, 71 file.Flush(); // Check page file for page 0 does exist yet - Assert.IsTrue(File.Exists(pageFile)); + ClassicAssert.IsTrue(File.Exists(pageFile)); } } } @@ -116,7 +117,7 @@ public void ExistingFile_EditSinglePage_Rollback([Values(1, 17, 7173)] int pageS var pageFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(baseDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.UncommittedPage, 0); // Check pagefile for page 0 doesn't exist yet - Assert.IsTrue(!File.Exists(pageFile)); + ClassicAssert.IsTrue(!File.Exists(pageFile)); // Cause page 0 to be flushed file.Flush(); @@ -128,7 +129,7 @@ public void ExistingFile_EditSinglePage_Rollback([Values(1, 17, 7173)] int pageS AssertSingleFile(baseDir, fileName); // Contains original data, no changes - Assert.AreEqual(originalData, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(originalData, File.ReadAllBytes(fileName)); } } @@ -153,7 +154,7 @@ public void ExistingFile_EditSinglePage_Commit([Values(1, 17, 7173)] int pageSiz var pageFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(baseDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.UncommittedPage, 0); // Check pagefile for page 0 doesn't exist yet - Assert.IsTrue(!File.Exists(pageFile)); + ClassicAssert.IsTrue(!File.Exists(pageFile)); // Cause page 0 to be flushed file.Flush(); @@ -165,7 +166,7 @@ public void ExistingFile_EditSinglePage_Commit([Values(1, 17, 7173)] int pageSiz AssertSingleFile(baseDir, fileName); // Contains transformed data, with changes - Assert.AreEqual(originalData.Select(b => b ^ b).ToArray(), File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(originalData.Select(b => b ^ b).ToArray(), File.ReadAllBytes(fileName)); } } @@ -193,7 +194,7 @@ public void ExistingFile_EditSinglePage_Resume_Commit([Values(1, 17, 7173)] int AssertSingleFile(baseDir, fileName); // Contains transformed data, with changes - Assert.AreEqual(originalData.Select(b => b ^ b).ToArray(), File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(originalData.Select(b => b ^ b).ToArray(), File.ReadAllBytes(fileName)); } } @@ -221,7 +222,7 @@ public void ExistingFile_EditSinglePage_Resume_Rollback([Values(1, 17, 7173)] in AssertSingleFile(baseDir, fileName); // Contains original data, no changes - Assert.AreEqual(originalData, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(originalData, File.ReadAllBytes(fileName)); } } @@ -241,7 +242,7 @@ public void ExistingFile_DeleteSinglePage_MarkerCreated([Values(1, 17, 7173)] in // delete data file.RemoveRange(0, file.Count); var markerFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(file.PageMarkerRepo.BaseDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.DeletedMarker, 0); - Assert.IsTrue(File.Exists(markerFile)); + ClassicAssert.IsTrue(File.Exists(markerFile)); } } } @@ -267,7 +268,7 @@ public void ExistingFile_DeleteSinglePage_MarkerNotCreated([Values(1, 17, 7173)] file.RemoveRange(lastPage.StartIndex, lastPage.Count); var markerFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(file.PageMarkerRepo.BaseDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.DeletedMarker, lastPage.Number); - Assert.IsFalse(File.Exists(markerFile)); + ClassicAssert.IsFalse(File.Exists(markerFile)); } } } @@ -288,7 +289,7 @@ public void ExistingFile_DeleteSinglePage_Rollback([Values(1, 17, 7173)] int pag // delete data file.RemoveRange(0, file.Count); var markerFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(file.PageMarkerRepo.BaseDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.DeletedMarker, 0); - Assert.IsTrue(File.Exists(markerFile)); + ClassicAssert.IsTrue(File.Exists(markerFile)); // rollback transaction file.Rollback(); @@ -297,7 +298,7 @@ public void ExistingFile_DeleteSinglePage_Rollback([Values(1, 17, 7173)] int pag AssertSingleFile(baseDir, fileName); // Contains original data, no changes - Assert.AreEqual(originalData, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(originalData, File.ReadAllBytes(fileName)); } } @@ -317,7 +318,7 @@ public void ExistingFile_DeleteSinglePage_Commit([Values(1, 17, 7173)] int pageS // delete data file.RemoveRange(0, file.Count); var markerFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(file.PageMarkerRepo.BaseDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.DeletedMarker, 0); - Assert.IsTrue(File.Exists(markerFile)); + ClassicAssert.IsTrue(File.Exists(markerFile)); // Commit transaction file.Commit(); } @@ -325,7 +326,7 @@ public void ExistingFile_DeleteSinglePage_Commit([Values(1, 17, 7173)] int pageS AssertSingleFile(baseDir, fileName); // Contains transformed data, with changes - Assert.AreEqual(new byte[0], File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(new byte[0], File.ReadAllBytes(fileName)); } } @@ -353,7 +354,7 @@ public void ExistingFile_DeleteSinglePage_Resume_Commit([Values(1, 17, 7173)] in AssertSingleFile(baseDir, fileName); // Contains transformed data, with changes - Assert.AreEqual(new byte[0], File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(new byte[0], File.ReadAllBytes(fileName)); } } @@ -381,7 +382,7 @@ public void ExistingFile_DeleteSinglePage_Resume_Rollback([Values(1, 17, 7173)] AssertSingleFile(baseDir, fileName); // Contains original data, no changes - Assert.AreEqual(originalData, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(originalData, File.ReadAllBytes(fileName)); } } @@ -405,7 +406,7 @@ public void ExistingFile_DeleteTwoPage_Commit([Values(1, 17, 7173)] int pageSize // delete data file.RemoveRange(file.Pages[1].StartIndex, file.Pages[1].Count); var markerFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(pagesDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.DeletedMarker, 1); - Assert.IsTrue(File.Exists(markerFile)); + ClassicAssert.IsTrue(File.Exists(markerFile)); // Commit transaction file.Commit(); } @@ -413,7 +414,7 @@ public void ExistingFile_DeleteTwoPage_Commit([Values(1, 17, 7173)] int pageSize AssertSingleFile(baseDir, fileName); // Contains transformed data, with changes - Assert.AreEqual(originalData.Take(pageSize).ToArray(), File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(originalData.Take(pageSize).ToArray(), File.ReadAllBytes(fileName)); } } @@ -436,8 +437,8 @@ public void ExistingFile_DeleteTwoPage_MarkerCreated([Values(1, 17, 7173)] int p var markerFile1 = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(pagesDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.DeletedMarker, lastPages[0].Number); var markerFile2 = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(pagesDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.DeletedMarker, lastPages[1].Number); - Assert.IsTrue(File.Exists(markerFile1)); - Assert.IsTrue(File.Exists(markerFile2)); + ClassicAssert.IsTrue(File.Exists(markerFile1)); + ClassicAssert.IsTrue(File.Exists(markerFile2)); } } } @@ -464,8 +465,8 @@ public void ExistingFile_DeleteTwoPage_MarkerNotCreated([Values(1, 17, 7173)] in var markerFile1 = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(baseDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.DeletedMarker, lastPages[0].Number); var markerFile2 = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(baseDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.DeletedMarker, lastPages[1].Number); - Assert.IsFalse(File.Exists(markerFile1)); - Assert.IsFalse(File.Exists(markerFile2)); + ClassicAssert.IsFalse(File.Exists(markerFile1)); + ClassicAssert.IsFalse(File.Exists(markerFile2)); } } } @@ -493,8 +494,8 @@ public void Special_DeletePartialPage_Rollback() { file.RemoveRange(pageSize + lastPageRemainingData, pageSize - lastPageRemainingData); file.Flush(); var markerFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(pagesDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.UncommittedPage, 1); - Assert.IsTrue(File.Exists(markerFile)); - Assert.AreEqual(lastPageRemainingData, Tools.FileSystem.GetFileSize(markerFile)); + ClassicAssert.IsTrue(File.Exists(markerFile)); + ClassicAssert.AreEqual(lastPageRemainingData, Tools.FileSystem.GetFileSize(markerFile)); // Commit transaction file.Rollback(); @@ -503,7 +504,7 @@ public void Special_DeletePartialPage_Rollback() { AssertSingleFile(baseDir, fileName); // Contains transformed data, with changes - Assert.AreEqual(originalData, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(originalData, File.ReadAllBytes(fileName)); } } @@ -526,8 +527,8 @@ public void Special_DeletePartialPage_Commit() { file.RemoveRange(pageSize + lastPageRemainingData, pageSize - lastPageRemainingData); file.Flush(); var markerFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(pagesDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.UncommittedPage, 1); - Assert.IsTrue(File.Exists(markerFile)); - Assert.AreEqual(lastPageRemainingData, Tools.FileSystem.GetFileSize(markerFile)); + ClassicAssert.IsTrue(File.Exists(markerFile)); + ClassicAssert.AreEqual(lastPageRemainingData, Tools.FileSystem.GetFileSize(markerFile)); // Commit transaction file.Commit(); @@ -538,7 +539,7 @@ public void Special_DeletePartialPage_Commit() { // Contains transformed data, with changes var expected = originalData.Take(pageSize + lastPageRemainingData).ToArray(); var actual = File.ReadAllBytes(fileName); - Assert.AreEqual(expected, actual); + ClassicAssert.AreEqual(expected, actual); } } @@ -564,7 +565,7 @@ public void Special_HasDeletePageMarkers([Values(1, 10, 100)] int maxOpenPages) // check deleted pages 3..10 exist for (var i = 2; i < 10; i++) { var markerFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(pagesDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.DeletedMarker, i); - Assert.IsTrue(File.Exists(markerFile)); + ClassicAssert.IsTrue(File.Exists(markerFile)); } // Commit transaction @@ -576,7 +577,7 @@ public void Special_HasDeletePageMarkers([Values(1, 10, 100)] int maxOpenPages) // Contains transformed data, with changes var expected = originalData; var actual = File.ReadAllBytes(fileName); - Assert.AreEqual(expected, actual); + ClassicAssert.AreEqual(expected, actual); } } @@ -592,7 +593,7 @@ public void Special_NoDeletePageMarkers([Values(1, 10, 100)] int maxOpenPages) { Tools.FileSystem.AppendAllBytes(fileName, originalData); using (Tools.Scope.ExecuteOnDispose(() => Tools.FileSystem.DeleteDirectory(baseDir))) { using (var file = new TransactionalFileMappedBuffer(TransactionalFileDescriptor.From(fileName, pageSize, maxOpenPages * pageSize), FileAccessMode.OpenOrCreate)) { - Assert.IsTrue(file.RequiresLoad); + ClassicAssert.IsTrue(file.RequiresLoad); file.Load(); // No pages should exist after load @@ -604,7 +605,7 @@ public void Special_NoDeletePageMarkers([Values(1, 10, 100)] int maxOpenPages) { // check deleted pages 3..10 exist for (var i = 2; i < 10; i++) { var markerFile = TransactionalFileMappedBuffer.MarkerRepository.GeneratePageMarkerFileName(pagesDir, file.FileID, TransactionalFileMappedBuffer.PageMarkerType.UncommittedPage, i); - Assert.IsTrue(File.Exists(markerFile)); + ClassicAssert.IsTrue(File.Exists(markerFile)); } // Delete pages 3..10 @@ -623,7 +624,7 @@ public void Special_NoDeletePageMarkers([Values(1, 10, 100)] int maxOpenPages) { // Contains transformed data, with changes var expected = originalData; var actual = File.ReadAllBytes(fileName); - Assert.AreEqual(expected, actual); + ClassicAssert.AreEqual(expected, actual); } } @@ -726,17 +727,17 @@ public void CommitEvents() { file.Committing += () => committingCount++; file.Committed += () => committedCount++; file.AddRange(new Random(31337).NextBytes(100)); - Assert.AreEqual(0, committingCount); - Assert.AreEqual(0, committedCount); - Assert.AreEqual(0, rollingBackCount); - Assert.AreEqual(0, rolledBackCount); + ClassicAssert.AreEqual(0, committingCount); + ClassicAssert.AreEqual(0, committedCount); + ClassicAssert.AreEqual(0, rollingBackCount); + ClassicAssert.AreEqual(0, rolledBackCount); // Commit transaction file.Commit(); - Assert.AreEqual(1, committingCount); - Assert.AreEqual(1, committedCount); - Assert.AreEqual(0, rollingBackCount); - Assert.AreEqual(0, rolledBackCount); + ClassicAssert.AreEqual(1, committingCount); + ClassicAssert.AreEqual(1, committedCount); + ClassicAssert.AreEqual(0, rollingBackCount); + ClassicAssert.AreEqual(0, rolledBackCount); } @@ -756,17 +757,17 @@ public void RollbackEvents() { file.RollingBack += () => rollingBackCount++; file.RolledBack += () => rolledBackCount++; file.AddRange(new Random(31337).NextBytes(100)); - Assert.AreEqual(0, committingCount); - Assert.AreEqual(0, committedCount); + ClassicAssert.AreEqual(0, committingCount); + ClassicAssert.AreEqual(0, committedCount); - Assert.AreEqual(0, rollingBackCount); - Assert.AreEqual(0, rolledBackCount); + ClassicAssert.AreEqual(0, rollingBackCount); + ClassicAssert.AreEqual(0, rolledBackCount); // Commit transaction file.Rollback(); - Assert.AreEqual(0, committingCount); - Assert.AreEqual(0, committedCount); - Assert.AreEqual(1, rollingBackCount); - Assert.AreEqual(1, rolledBackCount); + ClassicAssert.AreEqual(0, committingCount); + ClassicAssert.AreEqual(0, committedCount); + ClassicAssert.AreEqual(1, rollingBackCount); + ClassicAssert.AreEqual(1, rolledBackCount); } } @@ -802,7 +803,7 @@ public void Integration_Commit( IEnumerable newItems = RNG.NextBytes(newItemsCount); file.AddRange(newItems); expected.AddRange(newItems); - Assert.AreEqual(expected, file); + ClassicAssert.AreEqual(expected, file); // update a random amount if (file.Count > 0) { @@ -810,7 +811,7 @@ public void Integration_Commit( newItems = RNG.NextBytes(range.End - range.Start + 1); expected.UpdateRangeSequentially(range.Start, newItems); file.UpdateRange(range.Start, newItems); - Assert.AreEqual(expected, file); + ClassicAssert.AreEqual(expected, file); // shuffle a random amount range = RNG.NextRange((int)file.Count); @@ -821,20 +822,20 @@ public void Integration_Commit( expected.UpdateRangeSequentially(range.Start, expectedNewItems); file.UpdateRange(range.Start, newItems); - Assert.AreEqual(expected.Count, file.Count); - Assert.AreEqual(expected, file); + ClassicAssert.AreEqual(expected.Count, file.Count); + ClassicAssert.AreEqual(expected, file); // remove a random amount (FROM END OF LIST) range = new ValueRange(RNG.Next(0, (int)file.Count), (int)file.Count - 1); file.RemoveRange(range.Start, range.End - range.Start + 1); expected.RemoveRange(range.Start, range.End - range.Start + 1); - Assert.AreEqual(expected, file); + ClassicAssert.AreEqual(expected, file); } } file.Commit(); } var fileBytes = File.ReadAllBytes(fileName); - Assert.AreEqual(expected, fileBytes); + ClassicAssert.AreEqual(expected, fileBytes); } } @@ -865,7 +866,7 @@ public void Intergration_ResumeCommit( file.Load(); // initial check - Assert.AreEqual(expected, file); + ClassicAssert.AreEqual(expected, file); for (var i = 0; i < 10; i++) { // add a random amount @@ -874,7 +875,7 @@ public void Intergration_ResumeCommit( IEnumerable newItems = RNG.NextBytes(newItemsCount); file.AddRange(newItems); expected.AddRange(newItems); - Assert.AreEqual(expected, file); + ClassicAssert.AreEqual(expected, file); // update a random amount if (file.Count > 0) { @@ -882,7 +883,7 @@ public void Intergration_ResumeCommit( newItems = RNG.NextBytes(range.End - range.Start + 1); expected.UpdateRangeSequentially(range.Start, newItems); file.UpdateRange(range.Start, newItems); - Assert.AreEqual(expected, file); + ClassicAssert.AreEqual(expected, file); // shuffle a random amount range = RNG.NextRange((int)file.Count); @@ -893,14 +894,14 @@ public void Intergration_ResumeCommit( expected.UpdateRangeSequentially(range.Start, expectedNewItems); file.UpdateRange(range.Start, newItems); - Assert.AreEqual(expected.Count, file.Count); - Assert.AreEqual(expected, file); + ClassicAssert.AreEqual(expected.Count, file.Count); + ClassicAssert.AreEqual(expected, file); // remove a random amount (FROM END OF LIST) range = new ValueRange(RNG.Next(0, (int)file.Count), (int)file.Count - 1); file.RemoveRange(range.Start, range.End - range.Start + 1); expected.RemoveRange(range.Start, range.End - range.Start + 1); - Assert.AreEqual(expected, file); + ClassicAssert.AreEqual(expected, file); } } file.Flush(); // write all pages to disk @@ -923,7 +924,7 @@ public void Intergration_ResumeCommit( using (var file = new TransactionalFileMappedBuffer(TransactionalFileDescriptor.From(fileName, pageBaseDir, pageSize, maxOpenPages * pageSize))) { file.Load(); // should resume commit } - Assert.AreEqual(expected, File.ReadAllBytes(fileName)); + ClassicAssert.AreEqual(expected, File.ReadAllBytes(fileName)); } } diff --git a/tests/Hydrogen.Tests/Comparers/ByteArrayComparerTests.cs b/tests/Hydrogen.Tests/Comparers/ByteArrayComparerTests.cs index d57bf5344..18f5b8635 100644 --- a/tests/Hydrogen.Tests/Comparers/ByteArrayComparerTests.cs +++ b/tests/Hydrogen.Tests/Comparers/ByteArrayComparerTests.cs @@ -7,6 +7,7 @@ // This notice must not be removed when duplicating this file or its contents, in whole or in part. using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -16,26 +17,26 @@ public class ByteArrayComparerTests { [Test] public void TestNull() { - Assert.AreEqual(0, ByteArrayComparer.Instance.Compare(null, null)); + ClassicAssert.AreEqual(0, ByteArrayComparer.Instance.Compare(null, null)); } [Test] public void TestEmpty() { - Assert.AreEqual(0, ByteArrayComparer.Instance.Compare(new byte[0], new byte[0])); + ClassicAssert.AreEqual(0, ByteArrayComparer.Instance.Compare(new byte[0], new byte[0])); } [Test] public void TestSame() { - Assert.AreEqual(0, ByteArrayComparer.Instance.Compare(new byte[] { 1, 2, 3 }, new byte[] { 1, 2, 3 })); + ClassicAssert.AreEqual(0, ByteArrayComparer.Instance.Compare(new byte[] { 1, 2, 3 }, new byte[] { 1, 2, 3 })); } [Test] public void TestSmaller() { - Assert.AreEqual(-1, ByteArrayComparer.Instance.Compare(new byte[] { 1, 2, 3 }, new byte[] { 3, 2, 1 })); + ClassicAssert.AreEqual(-1, ByteArrayComparer.Instance.Compare(new byte[] { 1, 2, 3 }, new byte[] { 3, 2, 1 })); } [Test] public void TestGreater() { - Assert.AreEqual(1, ByteArrayComparer.Instance.Compare(new byte[] { 3, 2, 1 }, new byte[] { 1, 2, 3 })); + ClassicAssert.AreEqual(1, ByteArrayComparer.Instance.Compare(new byte[] { 3, 2, 1 }, new byte[] { 1, 2, 3 })); } } diff --git a/tests/Hydrogen.Tests/Comparers/ByteArrayEqualityComparerTests.cs b/tests/Hydrogen.Tests/Comparers/ByteArrayEqualityComparerTests.cs index 28c5bca79..4c0f82a25 100644 --- a/tests/Hydrogen.Tests/Comparers/ByteArrayEqualityComparerTests.cs +++ b/tests/Hydrogen.Tests/Comparers/ByteArrayEqualityComparerTests.cs @@ -7,6 +7,7 @@ // This notice must not be removed when duplicating this file or its contents, in whole or in part. using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -17,32 +18,32 @@ public class ByteArrayEqualityComparerTests { [Test] public void TestNull() { - Assert.AreEqual(true, ByteArrayEqualityComparer.Instance.Equals(null, null)); + ClassicAssert.AreEqual(true, ByteArrayEqualityComparer.Instance.Equals(null, null)); } [Test] public void TestEmpty() { - Assert.AreEqual(true, ByteArrayEqualityComparer.Instance.Equals(new byte[0], new byte[0])); + ClassicAssert.AreEqual(true, ByteArrayEqualityComparer.Instance.Equals(new byte[0], new byte[0])); } [Test] public void TestSame() { - Assert.AreEqual(true, ByteArrayEqualityComparer.Instance.Equals(new byte[] { 1, 2 }, new byte[] { 1, 2 })); + ClassicAssert.AreEqual(true, ByteArrayEqualityComparer.Instance.Equals(new byte[] { 1, 2 }, new byte[] { 1, 2 })); } [Test] public void TestDiff() { - Assert.AreEqual(false, ByteArrayEqualityComparer.Instance.Equals(new byte[] { 1, 2 }, new byte[] { 2, 1 })); + ClassicAssert.AreEqual(false, ByteArrayEqualityComparer.Instance.Equals(new byte[] { 1, 2 }, new byte[] { 2, 1 })); } [Test] public void TestDiffLonger_1() { - Assert.AreEqual(false, ByteArrayEqualityComparer.Instance.Equals(new byte[] { 1, 2, 3 }, new byte[] { 2, 1 })); + ClassicAssert.AreEqual(false, ByteArrayEqualityComparer.Instance.Equals(new byte[] { 1, 2, 3 }, new byte[] { 2, 1 })); } [Test] public void TestDiffLonger_2() { - Assert.AreEqual(false, ByteArrayEqualityComparer.Instance.Equals(new byte[] { 1, 2 }, new byte[] { 2, 1, 3 })); + ClassicAssert.AreEqual(false, ByteArrayEqualityComparer.Instance.Equals(new byte[] { 1, 2 }, new byte[] { 2, 1, 3 })); } } diff --git a/tests/Hydrogen.Tests/Comparers/ComparerBuilderTests.cs b/tests/Hydrogen.Tests/Comparers/ComparerBuilderTests.cs index 7a1e9ad7c..0aed40993 100644 --- a/tests/Hydrogen.Tests/Comparers/ComparerBuilderTests.cs +++ b/tests/Hydrogen.Tests/Comparers/ComparerBuilderTests.cs @@ -9,6 +9,7 @@ using System.Linq; using Hydrogen.NUnit; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -38,7 +39,7 @@ public void TestComparerBuilder() { items[0] }; var actual = items.OrderBy(x => x, comparer).ToArray(); - CollectionAssert.AreEqual(expected, actual); + ClassicAssert.AreEqual(expected, actual); } [Test] diff --git a/tests/Hydrogen.Tests/Comparers/PackedComparerTests.cs b/tests/Hydrogen.Tests/Comparers/PackedComparerTests.cs index f9a872d46..09fb4534d 100644 --- a/tests/Hydrogen.Tests/Comparers/PackedComparerTests.cs +++ b/tests/Hydrogen.Tests/Comparers/PackedComparerTests.cs @@ -9,6 +9,7 @@ using System; using System.Collections.Generic; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -43,12 +44,12 @@ public void TestUnpack_WrongTypeThrows() { public void TestCompare_Consistency() { IComparer stringComparer = StringComparer.InvariantCultureIgnoreCase; var packedComparer = stringComparer.AsPacked(); - Assert.AreEqual(stringComparer.Compare(null, null), packedComparer.Compare(null, null)); - Assert.AreEqual(stringComparer.Compare(null, "B"), packedComparer.Compare(null, "B")); - Assert.AreEqual(stringComparer.Compare("A", null), packedComparer.Compare("A", null)); - Assert.AreEqual(stringComparer.Compare("a", "b"), packedComparer.Compare("a", "b")); - Assert.AreEqual(stringComparer.Compare("a", "a"), packedComparer.Compare("a", "a")); - Assert.AreEqual(stringComparer.Compare("a", "A"), packedComparer.Compare("a", "A")); + ClassicAssert.AreEqual(stringComparer.Compare(null, null), packedComparer.Compare(null, null)); + ClassicAssert.AreEqual(stringComparer.Compare(null, "B"), packedComparer.Compare(null, "B")); + ClassicAssert.AreEqual(stringComparer.Compare("A", null), packedComparer.Compare("A", null)); + ClassicAssert.AreEqual(stringComparer.Compare("a", "b"), packedComparer.Compare("a", "b")); + ClassicAssert.AreEqual(stringComparer.Compare("a", "a"), packedComparer.Compare("a", "a")); + ClassicAssert.AreEqual(stringComparer.Compare("a", "A"), packedComparer.Compare("a", "A")); } [Test] diff --git a/tests/Hydrogen.Tests/Comparers/PackedEqualityComparerTests.cs b/tests/Hydrogen.Tests/Comparers/PackedEqualityComparerTests.cs index 669d59b75..aa62f8cf9 100644 --- a/tests/Hydrogen.Tests/Comparers/PackedEqualityComparerTests.cs +++ b/tests/Hydrogen.Tests/Comparers/PackedEqualityComparerTests.cs @@ -9,6 +9,7 @@ using System; using System.Collections.Generic; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -43,12 +44,12 @@ public void TestUnpack_WrongTypeThrows() { public void TestEquals_Consistency() { IEqualityComparer stringComparer = StringComparer.InvariantCultureIgnoreCase; var packedComparer = stringComparer.AsPacked(); - Assert.AreEqual(stringComparer.Equals(null, null), packedComparer.Equals(null, null)); - Assert.AreEqual(stringComparer.Equals(null, "B"), packedComparer.Equals(null, "B")); - Assert.AreEqual(stringComparer.Equals("A", null), packedComparer.Equals("A", null)); - Assert.AreEqual(stringComparer.Equals("a", "b"), packedComparer.Equals("a", "b")); - Assert.AreEqual(stringComparer.Equals("a", "a"), packedComparer.Equals("a", "a")); - Assert.AreEqual(stringComparer.Equals("a", "A"), packedComparer.Equals("a", "A")); + ClassicAssert.AreEqual(stringComparer.Equals(null, null), packedComparer.Equals(null, null)); + ClassicAssert.AreEqual(stringComparer.Equals(null, "B"), packedComparer.Equals(null, "B")); + ClassicAssert.AreEqual(stringComparer.Equals("A", null), packedComparer.Equals("A", null)); + ClassicAssert.AreEqual(stringComparer.Equals("a", "b"), packedComparer.Equals("a", "b")); + ClassicAssert.AreEqual(stringComparer.Equals("a", "a"), packedComparer.Equals("a", "a")); + ClassicAssert.AreEqual(stringComparer.Equals("a", "A"), packedComparer.Equals("a", "A")); } [Test] @@ -69,9 +70,9 @@ public void TestEquals_WrongTypeThrowsCastException_2() { public void TestGetHashCode_Consistency() { IEqualityComparer stringComparer = StringComparer.InvariantCultureIgnoreCase; var packedComparer = stringComparer.AsPacked(); - Assert.AreEqual(stringComparer.GetHashCode("a"), packedComparer.GetHashCode("a")); - Assert.AreEqual(stringComparer.GetHashCode("B"), packedComparer.GetHashCode("B")); - Assert.AreEqual(stringComparer.GetHashCode("c"), packedComparer.GetHashCode("c")); + ClassicAssert.AreEqual(stringComparer.GetHashCode("a"), packedComparer.GetHashCode("a")); + ClassicAssert.AreEqual(stringComparer.GetHashCode("B"), packedComparer.GetHashCode("B")); + ClassicAssert.AreEqual(stringComparer.GetHashCode("c"), packedComparer.GetHashCode("c")); } [Test] diff --git a/tests/Hydrogen.Tests/Crypto/HashersTests.cs b/tests/Hydrogen.Tests/Crypto/HashersTests.cs index 74f56e048..690f11043 100644 --- a/tests/Hydrogen.Tests/Crypto/HashersTests.cs +++ b/tests/Hydrogen.Tests/Crypto/HashersTests.cs @@ -9,6 +9,7 @@ using System; using NUnit.Framework; using System.Linq; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -30,7 +31,7 @@ public void Aggregate([Values(1, 2, 3, 100)] int n) { foreach (var item in items.Skip(1)) expected = Hashers.JoinHash(CHF.SHA2_256, expected, item); - Assert.AreEqual(expected, Hashers.Aggregate(CHF.SHA2_256, items)); + ClassicAssert.AreEqual(expected, Hashers.Aggregate(CHF.SHA2_256, items)); } } diff --git a/tests/Hydrogen.Tests/Crypto/SubRootTreeTests.cs b/tests/Hydrogen.Tests/Crypto/SubRootTreeTests.cs index 899a6b4f5..5b79b048d 100644 --- a/tests/Hydrogen.Tests/Crypto/SubRootTreeTests.cs +++ b/tests/Hydrogen.Tests/Crypto/SubRootTreeTests.cs @@ -23,15 +23,15 @@ // [Test] // public void NullRoot() { // var tree = new SubRootTree(CHF.SHA2_256); -// Assert.AreEqual(null, tree.Root); +// ClassicAssert.AreEqual(null, tree.Root); // } // [Test] // public void Integration_Empty() { // var standard = new MerkleTree(CHF.SHA2_256); // var perfect = new SubRootTree(CHF.SHA2_256); -// Assert.AreEqual(standard.Size, perfect.Size); -// Assert.AreEqual(standard.Root, perfect.Root); +// ClassicAssert.AreEqual(standard.Size, perfect.Size); +// ClassicAssert.AreEqual(standard.Root, perfect.Root); // } // [Test] @@ -41,8 +41,8 @@ // var data = new Random(3133).NextBytes(32); // standard.Leafs.Add(data); // perfect.Leafs.Add(data); -// Assert.AreEqual(standard.Size, perfect.Size); -// Assert.AreEqual(standard.Root, perfect.Root); +// ClassicAssert.AreEqual(standard.Size, perfect.Size); +// ClassicAssert.AreEqual(standard.Root, perfect.Root); // } // [Test] @@ -54,8 +54,8 @@ // var data2 = rng.NextBytes(32); // standard.Leafs.AddRange(new[] { data1, data2 }); // perfect.Leafs.AddRange(new[] { data1, data2 }); -// Assert.AreEqual(standard.Size, perfect.Size); -// Assert.AreEqual(standard.Root, perfect.Root); +// ClassicAssert.AreEqual(standard.Size, perfect.Size); +// ClassicAssert.AreEqual(standard.Root, perfect.Root); // } // [Test] @@ -67,8 +67,8 @@ // var data = rng.NextBytes(32); // standard.Leafs.Add(data); // perfect.Leafs.Add(data); -// Assert.AreEqual(standard.Size, perfect.Size); -// Assert.AreEqual(standard.Root, perfect.Root); +// ClassicAssert.AreEqual(standard.Size, perfect.Size); +// ClassicAssert.AreEqual(standard.Root, perfect.Root); // } // } @@ -82,8 +82,8 @@ // standard.Leafs.Add(data); // perfect.Leafs.Add(data); // } -// Assert.AreEqual(standard.Size, perfect.Size); -// Assert.AreEqual(standard.Root, perfect.Root); +// ClassicAssert.AreEqual(standard.Size, perfect.Size); +// ClassicAssert.AreEqual(standard.Root, perfect.Root); // } diff --git a/tests/Hydrogen.Tests/Crypto/WAMSTests.cs b/tests/Hydrogen.Tests/Crypto/WAMSTests.cs index 591ba2025..292ae44ab 100644 --- a/tests/Hydrogen.Tests/Crypto/WAMSTests.cs +++ b/tests/Hydrogen.Tests/Crypto/WAMSTests.cs @@ -10,6 +10,7 @@ using System.Linq; using System.Text; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -43,9 +44,9 @@ public void Signature_Consistency( var sig = wams.Sign(key, Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"), (ulong)batch, 0); var sig2 = wams.Sign(key, Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"), (ulong)batch, 0); if (ots == AMSOTS.WOTS) - Assert.AreEqual(sig, sig2); + ClassicAssert.AreEqual(sig, sig2); else - Assert.AreNotEqual(sig, sig2); + ClassicAssert.AreNotEqual(sig, sig2); } [Test] @@ -64,7 +65,7 @@ public void SignVerify_Basic( var message = Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"); var sig = wams.Sign(privateKey, message, publicKey.BatchNo, 0); - Assert.IsTrue(wams.Verify(sig, message, publicKey)); + ClassicAssert.IsTrue(wams.Verify(sig, message, publicKey)); } [Test] @@ -85,7 +86,7 @@ public void SignVerify_AllOTSKeys( for (var i = 0; i < 1 << privateKey.Height; i++) { var sig = wams.SignDigest(privateKey, messageDigest, (ulong)batch, i); - Assert.IsTrue(wams.VerifyDigest(sig, messageDigest, publicKey.RawBytes)); + ClassicAssert.IsTrue(wams.VerifyDigest(sig, messageDigest, publicKey.RawBytes)); } } @@ -103,7 +104,7 @@ public void SigVerify_AllHeights( var message = Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"); var sig = wams.Sign(privateKey, message, publicKey.BatchNo, 0); - Assert.IsTrue(wams.Verify(sig, message, publicKey)); + ClassicAssert.IsTrue(wams.Verify(sig, message, publicKey)); } [Test] @@ -120,7 +121,7 @@ public void KeyTest_Basic_True( var privateKey = wams.GeneratePrivateKey(Secret); var publicKey = wams.DerivePublicKeyForBatch(privateKey, (ulong)batch); var bytes = publicKey.RawBytes.ToArray(); - Assert.IsTrue(wams.IsPublicKey(privateKey, bytes)); + ClassicAssert.IsTrue(wams.IsPublicKey(privateKey, bytes)); } [Test] @@ -140,7 +141,7 @@ public void KeyTest_Basic_False( unchecked { bytes[0] += 1; } - Assert.IsFalse(wams.IsPublicKey(privateKey, bytes)); + ClassicAssert.IsFalse(wams.IsPublicKey(privateKey, bytes)); } } diff --git a/tests/Hydrogen.Tests/Crypto/WOTSSharpTests.cs b/tests/Hydrogen.Tests/Crypto/WOTSSharpTests.cs index 4111d48bf..f833ac38b 100644 --- a/tests/Hydrogen.Tests/Crypto/WOTSSharpTests.cs +++ b/tests/Hydrogen.Tests/Crypto/WOTSSharpTests.cs @@ -8,6 +8,7 @@ using System; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -23,7 +24,7 @@ public void SigVerify_All_0( var wots = new WOTSSharp(w, optimized); var digest = Tools.Array.Gen(wots.Config.DigestSize, 0); var key = wots.GenerateKeys(); - Assert.IsTrue(wots.VerifyDigest(wots.SignDigest(key.PrivateKey, digest), key.PublicKey, digest)); + ClassicAssert.IsTrue(wots.VerifyDigest(wots.SignDigest(key.PrivateKey, digest), key.PublicKey, digest)); } [Test] @@ -35,7 +36,7 @@ public void SigVerify_All_1( var wots = new WOTSSharp(w, optimized); var digest = Tools.Array.Gen(wots.Config.DigestSize, 1); var key = wots.GenerateKeys(); - Assert.IsTrue(wots.VerifyDigest(wots.SignDigest(key.PrivateKey, digest), key.PublicKey, digest)); + ClassicAssert.IsTrue(wots.VerifyDigest(wots.SignDigest(key.PrivateKey, digest), key.PublicKey, digest)); } [Test] @@ -48,7 +49,7 @@ public void SigVerify_1( var key = wots.GenerateKeys(); var message = System.Text.Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"); var sig = wots.Sign(key.PrivateKey, message); - Assert.IsTrue(wots.Verify(sig, key.PublicKey, message)); + ClassicAssert.IsTrue(wots.Verify(sig, key.PublicKey, message)); } [Test] @@ -63,7 +64,7 @@ public void SigVerify_Fail( var sig = wots.Sign(key.PrivateKey, message); unchecked { sig[0, 0] = (byte)(sig[0, 0] + 1); - Assert.IsFalse(wots.Verify(sig, key.PublicKey, message)); + ClassicAssert.IsFalse(wots.Verify(sig, key.PublicKey, message)); } } @@ -80,7 +81,7 @@ public void SigVerify_Integration_1( for (var i = 0; i < TestRounds; i++) { var message = RNG.NextBytes(RNG.Next(0, 100)); var sig = wots.Sign(key.PrivateKey, message); - Assert.IsTrue(wots.Verify(sig, key.PublicKey, message)); + ClassicAssert.IsTrue(wots.Verify(sig, key.PublicKey, message)); // flip a random byte var row = RNG.Next(0, sig.GetLength(0)); @@ -88,7 +89,7 @@ public void SigVerify_Integration_1( unchecked { sig[row, col] += 1; } - Assert.IsFalse(wots.Verify(sig, key.PublicKey, message)); + ClassicAssert.IsFalse(wots.Verify(sig, key.PublicKey, message)); } } diff --git a/tests/Hydrogen.Tests/Crypto/WOTSTests.cs b/tests/Hydrogen.Tests/Crypto/WOTSTests.cs index f4202043e..1d5345bba 100644 --- a/tests/Hydrogen.Tests/Crypto/WOTSTests.cs +++ b/tests/Hydrogen.Tests/Crypto/WOTSTests.cs @@ -9,6 +9,7 @@ using System; using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -26,7 +27,7 @@ [Values] bool optimized var key = wots.GenerateKeys(); var sig = wots.Sign(key.PrivateKey, System.Text.Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog")); var sig2 = wots.Sign(key.PrivateKey, System.Text.Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog")); - Assert.True(sig.AsFlatSpan().Slice(..^wots.Config.DigestSize).SequenceEqual(sig2.AsFlatSpan().Slice(..^wots.Config.DigestSize))); + ClassicAssert.IsTrue(sig.AsFlatSpan().Slice(..^wots.Config.DigestSize).SequenceEqual(sig2.AsFlatSpan().Slice(..^wots.Config.DigestSize))); } [Test] @@ -41,7 +42,7 @@ [Values] bool optimized var key = wots.GenerateKeys(); var sig = wots.SignDigest(key.PrivateKey, digest); // signature should be 2^w-1'th hash into the hash chain (private key is 1st) (exclusing digest) - Assert.AreEqual( + ClassicAssert.AreEqual( sig.ToFlatArray().Take(wots.Config.SignatureDigits * wots.Config.DigestSize), key .PrivateKey @@ -65,7 +66,7 @@ public void Digest_All_1( var sig = wots.SignDigest(key.PrivateKey, digest); // signature should be the private key (minus checksum) var nonFracitionalSignatureDigits = wots.Config.SignatureDigits - (wots.Config.SignatureDigits % wots.Config.W); - Assert.AreEqual( + ClassicAssert.AreEqual( sig.ToFlatArray().Take(nonFracitionalSignatureDigits * wots.Config.DigestSize), key.PrivateKey.ToFlatArray().Take(nonFracitionalSignatureDigits * wots.Config.DigestSize) ); @@ -80,7 +81,7 @@ public void SigVerify_All_0( var wots = new WOTS(w, optimized); var digest = Tools.Array.Gen(wots.Config.DigestSize, 0); var key = wots.GenerateKeys(); - Assert.IsTrue(wots.VerifyDigest(wots.SignDigest(key.PrivateKey, digest), key.PublicKey, digest)); + ClassicAssert.IsTrue(wots.VerifyDigest(wots.SignDigest(key.PrivateKey, digest), key.PublicKey, digest)); } [Test] @@ -92,7 +93,7 @@ public void SigVerify_All_1( var wots = new WOTS(w, optimized); var digest = Tools.Array.Gen(wots.Config.DigestSize, 1); var key = wots.GenerateKeys(); - Assert.IsTrue(wots.VerifyDigest(wots.SignDigest(key.PrivateKey, digest), key.PublicKey, digest)); + ClassicAssert.IsTrue(wots.VerifyDigest(wots.SignDigest(key.PrivateKey, digest), key.PublicKey, digest)); } [Test] @@ -105,7 +106,7 @@ public void SigVerify_1( var key = wots.GenerateKeys(); var message = System.Text.Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"); var sig = wots.Sign(key.PrivateKey, message); - Assert.IsTrue(wots.Verify(sig, key.PublicKey, message)); + ClassicAssert.IsTrue(wots.Verify(sig, key.PublicKey, message)); } [Test] @@ -114,7 +115,7 @@ public void SigVerify_w16() { var key = wots.GenerateKeys(); var message = System.Text.Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"); var sig = wots.Sign(key.PrivateKey, message); - Assert.IsTrue(wots.Verify(sig, key.PublicKey, message)); + ClassicAssert.IsTrue(wots.Verify(sig, key.PublicKey, message)); } [Test] @@ -129,7 +130,7 @@ public void SigVerify_Fail( var sig = wots.Sign(key.PrivateKey, message); unchecked { sig[0, 0] = (byte)(sig[0, 0] + 1); - Assert.IsFalse(wots.Verify(sig, key.PublicKey, message)); + ClassicAssert.IsFalse(wots.Verify(sig, key.PublicKey, message)); } } @@ -146,7 +147,7 @@ public void SigVerify_Integration_1( for (var i = 0; i < TestRounds; i++) { var message = RNG.NextBytes(RNG.Next(0, 100)); var sig = wots.Sign(key.PrivateKey, message); - Assert.IsTrue(wots.Verify(sig, key.PublicKey, message)); + ClassicAssert.IsTrue(wots.Verify(sig, key.PublicKey, message)); // flip a random byte var row = RNG.Next(0, sig.GetLength(0)); @@ -154,7 +155,7 @@ public void SigVerify_Integration_1( unchecked { sig[row, col] += 1; } - Assert.IsFalse(wots.Verify(sig, key.PublicKey, message)); + ClassicAssert.IsFalse(wots.Verify(sig, key.PublicKey, message)); } } diff --git a/tests/Hydrogen.Tests/DateTime/ApproxEqual.cs b/tests/Hydrogen.Tests/DateTime/ApproxEqual.cs index 485c9e220..e4b3707a0 100644 --- a/tests/Hydrogen.Tests/DateTime/ApproxEqual.cs +++ b/tests/Hydrogen.Tests/DateTime/ApproxEqual.cs @@ -8,6 +8,7 @@ using System; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -19,47 +20,47 @@ public class ApproxEqual { public void Exact() { var date = DateTime.Now; var test = date; - Assert.IsTrue(date.ApproxEqual(test)); + ClassicAssert.IsTrue(date.ApproxEqual(test)); } [Test] public void LessThanButWithinTolerance() { var date = DateTime.Now; var test = date.Subtract(TimeSpan.FromMilliseconds(100)); - Assert.IsTrue(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); + ClassicAssert.IsTrue(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); } [Test] public void LessThanButAtMaxTolerance() { var date = DateTime.Now; var test = date.Subtract(TimeSpan.FromMilliseconds(250)); - Assert.IsTrue(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); + ClassicAssert.IsTrue(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); } [Test] public void LessThanAndBeyondTolerance() { var date = DateTime.Now; var test = date.Subtract(TimeSpan.FromMilliseconds(251)); - Assert.IsFalse(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); + ClassicAssert.IsFalse(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); } [Test] public void GreaterThanButWithinTolerance() { var date = DateTime.Now; var test = date.Add(TimeSpan.FromMilliseconds(100)); - Assert.IsTrue(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); + ClassicAssert.IsTrue(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); } [Test] public void GreaterThanButAtMaxTolerance() { var date = DateTime.Now; var test = date.Add(TimeSpan.FromMilliseconds(250)); - Assert.IsTrue(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); + ClassicAssert.IsTrue(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); } [Test] public void GreaterThanAndBeyondTolerance() { var date = DateTime.Now; var test = date.Add(TimeSpan.FromMilliseconds(251)); - Assert.IsFalse(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); + ClassicAssert.IsFalse(date.ApproxEqual(test, TimeSpan.FromMilliseconds(250))); } } diff --git a/tests/Hydrogen.Tests/DateTime/FormatExTests.cs b/tests/Hydrogen.Tests/DateTime/FormatExTests.cs index f00f12164..5de8fcfea 100644 --- a/tests/Hydrogen.Tests/DateTime/FormatExTests.cs +++ b/tests/Hydrogen.Tests/DateTime/FormatExTests.cs @@ -8,6 +8,7 @@ using System; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -19,30 +20,30 @@ public class DateTimeTests { public void NextDayOfWeek_Tomorrow() { var startDayTime = new DateTime(2014, 09, 29); // Monday var nextDayOfWeek = startDayTime.ToNextDayOfWeek(DayOfWeek.Tuesday); - Assert.AreEqual(DayOfWeek.Tuesday, nextDayOfWeek.DayOfWeek); - Assert.AreEqual(30, nextDayOfWeek.Day); - Assert.AreEqual(9, nextDayOfWeek.Month); - Assert.AreEqual(2014, nextDayOfWeek.Year); + ClassicAssert.AreEqual(DayOfWeek.Tuesday, nextDayOfWeek.DayOfWeek); + ClassicAssert.AreEqual(30, nextDayOfWeek.Day); + ClassicAssert.AreEqual(9, nextDayOfWeek.Month); + ClassicAssert.AreEqual(2014, nextDayOfWeek.Year); } [Test] public void NextDayOfWeek_NextMonday() { var startDayTime = new DateTime(2014, 09, 29); // Monday var nextDayOfWeek = startDayTime.ToNextDayOfWeek(DayOfWeek.Monday); - Assert.AreEqual(DayOfWeek.Monday, nextDayOfWeek.DayOfWeek); - Assert.AreEqual(6, nextDayOfWeek.Day); - Assert.AreEqual(10, nextDayOfWeek.Month); - Assert.AreEqual(2014, nextDayOfWeek.Year); + ClassicAssert.AreEqual(DayOfWeek.Monday, nextDayOfWeek.DayOfWeek); + ClassicAssert.AreEqual(6, nextDayOfWeek.Day); + ClassicAssert.AreEqual(10, nextDayOfWeek.Month); + ClassicAssert.AreEqual(2014, nextDayOfWeek.Year); } [Test] public void NextDayOfWeek_NextSunday() { var startDayTime = new DateTime(2014, 09, 29); // Monday var nextDayOfWeek = startDayTime.ToNextDayOfWeek(DayOfWeek.Sunday); - Assert.AreEqual(DayOfWeek.Sunday, nextDayOfWeek.DayOfWeek); - Assert.AreEqual(5, nextDayOfWeek.Day); - Assert.AreEqual(10, nextDayOfWeek.Month); - Assert.AreEqual(2014, nextDayOfWeek.Year); + ClassicAssert.AreEqual(DayOfWeek.Sunday, nextDayOfWeek.DayOfWeek); + ClassicAssert.AreEqual(5, nextDayOfWeek.Day); + ClassicAssert.AreEqual(10, nextDayOfWeek.Month); + ClassicAssert.AreEqual(2014, nextDayOfWeek.Year); } @@ -50,22 +51,22 @@ public void NextDayOfWeek_NextSunday() { public void NextDayOfWeek_1HourAhead() { var startDayTime = new DateTime(2014, 09, 29, 11, 0, 0, 0); // Monday var nextDayOfWeek = startDayTime.ToNextDayOfWeek(DayOfWeek.Monday, TimeSpan.FromHours(12)); - Assert.AreEqual(nextDayOfWeek.DayOfWeek, startDayTime.DayOfWeek); - Assert.AreEqual(nextDayOfWeek.Day, startDayTime.Day); - Assert.AreEqual(nextDayOfWeek.Month, startDayTime.Month); - Assert.AreEqual(nextDayOfWeek.Year, startDayTime.Year); - Assert.AreEqual(12, nextDayOfWeek.Hour); + ClassicAssert.AreEqual(nextDayOfWeek.DayOfWeek, startDayTime.DayOfWeek); + ClassicAssert.AreEqual(nextDayOfWeek.Day, startDayTime.Day); + ClassicAssert.AreEqual(nextDayOfWeek.Month, startDayTime.Month); + ClassicAssert.AreEqual(nextDayOfWeek.Year, startDayTime.Year); + ClassicAssert.AreEqual(12, nextDayOfWeek.Hour); } [Test] public void NextDayOfWeek_168HoursAhead() { var startDayTime = new DateTime(2014, 09, 29, 12, 0, 0, 0); // Monday var nextDayOfWeek = startDayTime.ToNextDayOfWeek(DayOfWeek.Monday, TimeSpan.FromHours(12)); - Assert.AreEqual(nextDayOfWeek.DayOfWeek, startDayTime.DayOfWeek); - Assert.AreEqual(6, nextDayOfWeek.Day); - Assert.AreEqual(10, nextDayOfWeek.Month); - Assert.AreEqual(2014, nextDayOfWeek.Year); - Assert.AreEqual(12, nextDayOfWeek.Hour); + ClassicAssert.AreEqual(nextDayOfWeek.DayOfWeek, startDayTime.DayOfWeek); + ClassicAssert.AreEqual(6, nextDayOfWeek.Day); + ClassicAssert.AreEqual(10, nextDayOfWeek.Month); + ClassicAssert.AreEqual(2014, nextDayOfWeek.Year); + ClassicAssert.AreEqual(12, nextDayOfWeek.Hour); } @@ -73,10 +74,10 @@ public void NextDayOfWeek_168HoursAhead() { public void NextDayOfMonth_NextMonth() { var start = new DateTime(2014, 09, 29); // Monday var nextDayOfMonth = start.ToNextDayOfMonth(29); - Assert.AreEqual(DayOfWeek.Wednesday, nextDayOfMonth.DayOfWeek); - Assert.AreEqual(29, nextDayOfMonth.Day); - Assert.AreEqual(10, nextDayOfMonth.Month); - Assert.AreEqual(2014, nextDayOfMonth.Year); + ClassicAssert.AreEqual(DayOfWeek.Wednesday, nextDayOfMonth.DayOfWeek); + ClassicAssert.AreEqual(29, nextDayOfMonth.Day); + ClassicAssert.AreEqual(10, nextDayOfMonth.Month); + ClassicAssert.AreEqual(2014, nextDayOfMonth.Year); } @@ -84,31 +85,31 @@ public void NextDayOfMonth_NextMonth() { public void NextDayOfMonth_Tomorrow() { var start = new DateTime(2014, 09, 29); // Monday var nextDayOfMonth = start.ToNextDayOfMonth(30); - Assert.AreEqual(DayOfWeek.Tuesday, nextDayOfMonth.DayOfWeek); - Assert.AreEqual(30, nextDayOfMonth.Day); - Assert.AreEqual(9, nextDayOfMonth.Month); - Assert.AreEqual(2014, nextDayOfMonth.Year); + ClassicAssert.AreEqual(DayOfWeek.Tuesday, nextDayOfMonth.DayOfWeek); + ClassicAssert.AreEqual(30, nextDayOfMonth.Day); + ClassicAssert.AreEqual(9, nextDayOfMonth.Month); + ClassicAssert.AreEqual(2014, nextDayOfMonth.Year); } [Test] public void NextDayOfMonth_1HourAhead() { var start = new DateTime(2014, 09, 29, 11, 0, 0, 0); // Monday var nextDayOfMonth = start.ToNextDayOfMonth(29, TimeSpan.FromHours(12)); - Assert.AreEqual(nextDayOfMonth.DayOfWeek, start.DayOfWeek); - Assert.AreEqual(nextDayOfMonth.Day, start.Day); - Assert.AreEqual(nextDayOfMonth.Month, start.Month); - Assert.AreEqual(nextDayOfMonth.Year, start.Year); - Assert.AreEqual(12, nextDayOfMonth.Hour); + ClassicAssert.AreEqual(nextDayOfMonth.DayOfWeek, start.DayOfWeek); + ClassicAssert.AreEqual(nextDayOfMonth.Day, start.Day); + ClassicAssert.AreEqual(nextDayOfMonth.Month, start.Month); + ClassicAssert.AreEqual(nextDayOfMonth.Year, start.Year); + ClassicAssert.AreEqual(12, nextDayOfMonth.Hour); } [Test] public void NextDayOfMonth_MonthsHoursAhead() { var start = new DateTime(2014, 09, 29, 12, 0, 0, 0); // Monday var nextDayOfMonth = start.ToNextDayOfMonth(29, TimeSpan.FromHours(12)); - Assert.AreEqual(29, nextDayOfMonth.Day); - Assert.AreEqual(10, nextDayOfMonth.Month); - Assert.AreEqual(2014, nextDayOfMonth.Year); - Assert.AreEqual(12, nextDayOfMonth.Hour); + ClassicAssert.AreEqual(29, nextDayOfMonth.Day); + ClassicAssert.AreEqual(10, nextDayOfMonth.Month); + ClassicAssert.AreEqual(2014, nextDayOfMonth.Year); + ClassicAssert.AreEqual(12, nextDayOfMonth.Hour); } } diff --git a/tests/Hydrogen.Tests/Environment/CommandLineArgsTests.cs b/tests/Hydrogen.Tests/Environment/CommandLineArgsTests.cs index 88ba04628..7dfafd477 100644 --- a/tests/Hydrogen.Tests/Environment/CommandLineArgsTests.cs +++ b/tests/Hydrogen.Tests/Environment/CommandLineArgsTests.cs @@ -51,16 +51,16 @@ // "--p1", "c1", "--p2", "p2value", "c2", "--p3", "p3value", "--p3", "p3value2" // }); -// Assert.IsTrue(result.Success); +// ClassicAssert.IsTrue(result.Success); // var results = result.Value; -// Assert.IsTrue(results.Arguments.Contains("p1")); -// Assert.IsEmpty(results.Arguments["p1"]); -// Assert.AreEqual("c1", results.SubCommand.CommandName); -// Assert.AreEqual("p2value", results.SubCommand.Arguments["p2"].Single()); -// Assert.AreEqual("c2", results.SubCommand.SubCommand.CommandName); -// Assert.AreEqual("p3value", results.SubCommand.SubCommand.Arguments["p3"].First()); -// Assert.AreEqual("p3value2", results.SubCommand.SubCommand.Arguments["p3"].Skip(1).First()); +// ClassicAssert.IsTrue(results.Arguments.Contains("p1")); +// ClassicAssert.IsEmpty(results.Arguments["p1"]); +// ClassicAssert.AreEqual("c1", results.SubCommand.CommandName); +// ClassicAssert.AreEqual("p2value", results.SubCommand.Arguments["p2"].Single()); +// ClassicAssert.AreEqual("c2", results.SubCommand.SubCommand.CommandName); +// ClassicAssert.AreEqual("p3value", results.SubCommand.SubCommand.Arguments["p3"].First()); +// ClassicAssert.AreEqual("p3value2", results.SubCommand.SubCommand.Arguments["p3"].Skip(1).First()); // } // [Test] @@ -80,17 +80,17 @@ // }; // var result = args.TryParseArguments(new[] { "--p1", "--p2", "p2value", "--p3", "c1" }); -// Assert.IsEmpty(result.Value.Arguments["p1"]); -// Assert.AreEqual("p2value", result.Value.Arguments["p2"].Single()); -// Assert.IsEmpty(result.Value.Arguments["p3"]); -// Assert.AreEqual("c1", result.Value.SubCommand.CommandName); +// ClassicAssert.IsEmpty(result.Value.Arguments["p1"]); +// ClassicAssert.AreEqual("p2value", result.Value.Arguments["p2"].Single()); +// ClassicAssert.IsEmpty(result.Value.Arguments["p3"]); +// ClassicAssert.AreEqual("c1", result.Value.SubCommand.CommandName); // } // [Test] // public void DefaultConstructorParse() { // var args = new CommandLineParameters(); // var result = args.TryParseArguments(Array.Empty()); -// Assert.IsTrue(result.Success); +// ClassicAssert.IsTrue(result.Success); // } // [Test] @@ -105,9 +105,9 @@ // }; // var result = args.TryParseArguments(new string[] { "--test", "valid", "unittest" }); -// Assert.IsTrue(result.Success); -// Assert.AreEqual("unittest", result.Value.SubCommand.CommandName); -// Assert.AreEqual("valid", result.Value.Arguments["test"].Single()); +// ClassicAssert.IsTrue(result.Success); +// ClassicAssert.AreEqual("unittest", result.Value.SubCommand.CommandName); +// ClassicAssert.AreEqual("valid", result.Value.Arguments["test"].Single()); // } // [Test] @@ -122,9 +122,9 @@ // var result = args.TryParseArguments(Array.Empty()); -// Assert.IsTrue(result.Success); -// Assert.IsNull(result.Value.SubCommand); -// Assert.IsEmpty(result.Value.Arguments); +// ClassicAssert.IsTrue(result.Success); +// ClassicAssert.IsNull(result.Value.SubCommand); +// ClassicAssert.IsEmpty(result.Value.Arguments); // } // [Test] @@ -138,7 +138,7 @@ // }); // var result = args.TryParseArguments(new[] { "test2", "--baz" }); -// Assert.IsTrue(result.Failure); +// ClassicAssert.IsTrue(result.Failure); // } // [Test] @@ -152,7 +152,7 @@ // }); // var result = args.TryParseArguments(new[] { "test", "test2", "--baz" }); -// Assert.IsTrue(result.Failure); +// ClassicAssert.IsTrue(result.Failure); // } // [Test] @@ -171,12 +171,12 @@ // }); // var result = args.TryParseArguments(new[] { "test", "test-2", "--foo baz" }); -// Assert.IsTrue(result.Success); -// Assert.AreEqual("test", result.Value.SubCommand.CommandName); +// ClassicAssert.IsTrue(result.Success); +// ClassicAssert.AreEqual("test", result.Value.SubCommand.CommandName); // var testResult = result.Value.SubCommand; // var test2Results = testResult.SubCommand; -// Assert.AreEqual("baz", test2Results.Arguments["foo"].Single()); +// ClassicAssert.AreEqual("baz", test2Results.Arguments["foo"].Single()); // } // [Test] @@ -196,10 +196,10 @@ // }); // var invalid = args.TryParseArguments(new[] { "test", "test-2", "--fo0", "baz" }); -// Assert.IsFalse(invalid.Success); +// ClassicAssert.IsFalse(invalid.Success); // var valid = args.TryParseArguments(new[] { "test", "test-2", "--foo", "baz" }); -// Assert.IsTrue(valid.Success); +// ClassicAssert.IsTrue(valid.Success); // } // [Test] @@ -218,10 +218,10 @@ // }); // var result = args.TryParseArguments(new[] { "test", "test-2" }); -// Assert.IsTrue(result.Success); +// ClassicAssert.IsTrue(result.Success); -// Assert.AreEqual("test", result.Value.SubCommand.CommandName); -// Assert.AreEqual("test-2", result.Value.SubCommand.SubCommand.CommandName); +// ClassicAssert.AreEqual("test", result.Value.SubCommand.CommandName); +// ClassicAssert.AreEqual("test-2", result.Value.SubCommand.SubCommand.CommandName); // } // [Test] @@ -243,9 +243,9 @@ // var parsed = p.TryParseArguments(args); -// Assert.IsTrue(parsed.Success); -// Assert.AreEqual(1, parsed.Value.Arguments["test"].Count()); -// Assert.AreEqual("test", parsed.Value.Arguments["test"].Single()); +// ClassicAssert.IsTrue(parsed.Success); +// ClassicAssert.AreEqual(1, parsed.Value.Arguments["test"].Count()); +// ClassicAssert.AreEqual("test", parsed.Value.Arguments["test"].Single()); // } // [Test] @@ -268,8 +268,8 @@ // "--multi", "c" // }); -// Assert.IsTrue(parsed.Success); -// Assert.AreEqual(new[] { "a", "b", "c" }, parsed.Value.Arguments["multi"]); +// ClassicAssert.IsTrue(parsed.Success); +// ClassicAssert.AreEqual(new[] { "a", "b", "c" }, parsed.Value.Arguments["multi"]); // } // [Test] @@ -288,16 +288,16 @@ // "--single=c" // }); -// Assert.IsFalse(invalid.Success); -// Assert.AreEqual(1, invalid.ErrorMessages.Count()); +// ClassicAssert.IsFalse(invalid.Success); +// ClassicAssert.AreEqual(1, invalid.ErrorMessages.Count()); // var valid = args.TryParseArguments(new[] // { // "--single=c" // }); -// Assert.IsTrue(valid.Success); -// Assert.AreEqual("c", valid.Value.Arguments["single"].Single()); +// ClassicAssert.IsTrue(valid.Success); +// ClassicAssert.AreEqual("c", valid.Value.Arguments["single"].Single()); // } // [Test] @@ -317,17 +317,17 @@ // "test" // }); -// Assert.IsFalse(invalid.Success); -// Assert.AreEqual(1, invalid.ErrorMessages.Count()); -// Assert.IsEmpty(invalid.Value.Arguments); +// ClassicAssert.IsFalse(invalid.Success); +// ClassicAssert.AreEqual(1, invalid.ErrorMessages.Count()); +// ClassicAssert.IsEmpty(invalid.Value.Arguments); // var valid = args.TryParseArguments(new[] // { // "/mandatory", "test", // }); -// Assert.IsTrue(valid.Success); -// Assert.AreEqual("test", valid.Value.Arguments["mandatory"].Single()); +// ClassicAssert.IsTrue(valid.Success); +// ClassicAssert.AreEqual("test", valid.Value.Arguments["mandatory"].Single()); // } // [Test] @@ -349,17 +349,17 @@ // "/mandatory", "test", // }); -// Assert.IsFalse(invalid.Success); -// Assert.AreEqual(1, invalid.ErrorMessages.Count()); -// Assert.IsEmpty(invalid.Value.Arguments); +// ClassicAssert.IsFalse(invalid.Success); +// ClassicAssert.AreEqual(1, invalid.ErrorMessages.Count()); +// ClassicAssert.IsEmpty(invalid.Value.Arguments); // var valid = args.TryParseArguments(new[] // { // "/mAnDaToRy", "test", // }); -// Assert.IsTrue(valid.Success); -// Assert.AreEqual("test", valid.Value.Arguments["mAnDaToRy"].Single()); +// ClassicAssert.IsTrue(valid.Success); +// ClassicAssert.AreEqual("test", valid.Value.Arguments["mAnDaToRy"].Single()); // } // [Test] @@ -378,8 +378,8 @@ // "--h" // }); -// Assert.IsTrue(help.Success); -// Assert.IsTrue(help.Value.HelpRequested); +// ClassicAssert.IsTrue(help.Success); +// ClassicAssert.IsTrue(help.Value.HelpRequested); // } // [Test] @@ -397,8 +397,8 @@ // "--help" // }); -// Assert.IsTrue(help.Success); -// Assert.IsTrue(help.Value.HelpRequested); +// ClassicAssert.IsTrue(help.Success); +// ClassicAssert.IsTrue(help.Value.HelpRequested); // } // [Test] @@ -417,8 +417,8 @@ // "/mandatoryWithDependency", "test" // }); -// Assert.IsFalse(invalid.Success); -// Assert.AreEqual(1, invalid.ErrorMessages.Count()); +// ClassicAssert.IsFalse(invalid.Success); +// ClassicAssert.AreEqual(1, invalid.ErrorMessages.Count()); // var valid = args.TryParseArguments(new[] // { @@ -426,10 +426,10 @@ // "/test", "test" // }); -// Assert.IsTrue(valid.Success); -// Assert.IsEmpty(valid.ErrorMessages); -// Assert.AreEqual("test", valid.Value.Arguments["mandatoryWithDependency"].Single()); -// Assert.AreEqual("test", valid.Value.Arguments["test"].Single()); +// ClassicAssert.IsTrue(valid.Success); +// ClassicAssert.IsEmpty(valid.ErrorMessages); +// ClassicAssert.AreEqual("test", valid.Value.Arguments["mandatoryWithDependency"].Single()); +// ClassicAssert.AreEqual("test", valid.Value.Arguments["test"].Single()); // } // [Test] @@ -459,9 +459,9 @@ // }); // var parsed = args.TryParseArguments(input); -// Assert.IsTrue(parsed.Success); -// Assert.AreEqual(5, parsed.Value.Arguments.Count()); -// Assert.IsEmpty(parsed.ErrorMessages); +// ClassicAssert.IsTrue(parsed.Success); +// ClassicAssert.AreEqual(5, parsed.Value.Arguments.Count()); +// ClassicAssert.IsEmpty(parsed.ErrorMessages); // } // } //} diff --git a/tests/Hydrogen.Tests/FileSystem/FileSystemTests.cs b/tests/Hydrogen.Tests/FileSystem/FileSystemTests.cs index 24df3eb43..98205f528 100644 --- a/tests/Hydrogen.Tests/FileSystem/FileSystemTests.cs +++ b/tests/Hydrogen.Tests/FileSystem/FileSystemTests.cs @@ -9,6 +9,7 @@ using System; using NUnit.Framework; using System.IO; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -21,7 +22,7 @@ public void AvailableFile_1() { var file = Guid.NewGuid().ToStrictAlphaString(); var ext = ".ext"; var expectedPath = Path.Combine(path, file + ext); - Assert.AreEqual(expectedPath, Tools.FileSystem.DetermineAvailableFileName(path, file + ext)); + ClassicAssert.AreEqual(expectedPath, Tools.FileSystem.DetermineAvailableFileName(path, file + ext)); } [Test] @@ -32,7 +33,7 @@ public void AvailableFile_2() { var desiredPath = Path.Combine(path, file + ext); try { Tools.FileSystem.CreateBlankFile(desiredPath); - Assert.AreEqual(Path.Combine(path, file + " 2" + ext), Tools.FileSystem.DetermineAvailableFileName(path, file + ext)); + ClassicAssert.AreEqual(Path.Combine(path, file + " 2" + ext), Tools.FileSystem.DetermineAvailableFileName(path, file + ext)); } finally { File.Delete(Path.Combine(path, file + ext)); } @@ -46,7 +47,7 @@ public void AvailableFile_3() { try { Tools.FileSystem.CreateBlankFile(Path.Combine(path, file + ext)); Tools.FileSystem.CreateBlankFile(Path.Combine(path, file + " 2" + ext)); - Assert.AreEqual(Path.Combine(path, file + " 3" + ext), Tools.FileSystem.DetermineAvailableFileName(path, file + ext)); + ClassicAssert.AreEqual(Path.Combine(path, file + " 3" + ext), Tools.FileSystem.DetermineAvailableFileName(path, file + ext)); } finally { File.Delete(Path.Combine(path, file + ext)); File.Delete(Path.Combine(path, file + " 2" + ext)); diff --git a/tests/Hydrogen.Tests/Hydrogen.Tests.csproj b/tests/Hydrogen.Tests/Hydrogen.Tests.csproj index 2eaa6b94d..7ea9a3a66 100644 --- a/tests/Hydrogen.Tests/Hydrogen.Tests.csproj +++ b/tests/Hydrogen.Tests/Hydrogen.Tests.csproj @@ -19,6 +19,7 @@ + all runtime; build; native; contentfiles; analyzers; buildtransitive diff --git a/tests/Hydrogen.Tests/Iterator/AppendIteratorTests.cs b/tests/Hydrogen.Tests/Iterator/AppendIteratorTests.cs index 553bc3ef6..bf23cff1d 100644 --- a/tests/Hydrogen.Tests/Iterator/AppendIteratorTests.cs +++ b/tests/Hydrogen.Tests/Iterator/AppendIteratorTests.cs @@ -8,6 +8,7 @@ using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -20,8 +21,8 @@ public void TestUnionAntiPattern() { var data = new[] { "one" }; var union = data.Union("one"); var result = union.ToArray(); - Assert.AreEqual(1, result.Length); - Assert.AreEqual("one", result[0]); + ClassicAssert.AreEqual(1, result.Length); + ClassicAssert.AreEqual("one", result[0]); } [Test] @@ -29,9 +30,9 @@ public void TestConcat() { var data = new[] { "one" }; var union = data.Concat("one"); var result = union.ToArray(); - Assert.AreEqual(2, result.Length); - Assert.AreEqual("one", result[0]); - Assert.AreEqual("one", result[0]); + ClassicAssert.AreEqual(2, result.Length); + ClassicAssert.AreEqual("one", result[0]); + ClassicAssert.AreEqual("one", result[0]); } diff --git a/tests/Hydrogen.Tests/Memory/MemoryMetricTests.cs b/tests/Hydrogen.Tests/Memory/MemoryMetricTests.cs index 04485aace..6da3a3b95 100644 --- a/tests/Hydrogen.Tests/Memory/MemoryMetricTests.cs +++ b/tests/Hydrogen.Tests/Memory/MemoryMetricTests.cs @@ -7,6 +7,7 @@ // This notice must not be removed when duplicating this file or its contents, in whole or in part. using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -17,31 +18,31 @@ public class MemoryMetricTests { [Test] public void Byte2Bit() { - Assert.AreEqual(16, Tools.Memory.ConvertMemoryMetric(2, MemoryMetric.Byte, MemoryMetric.Bit)); + ClassicAssert.AreEqual(16, Tools.Memory.ConvertMemoryMetric(2, MemoryMetric.Byte, MemoryMetric.Bit)); } [Test] public void Bit2Byte() { - Assert.AreEqual(2, Tools.Memory.ConvertMemoryMetric(16, MemoryMetric.Bit, MemoryMetric.Byte)); + ClassicAssert.AreEqual(2, Tools.Memory.ConvertMemoryMetric(16, MemoryMetric.Bit, MemoryMetric.Byte)); } [Test] public void Kilobyte2Byte() { - Assert.AreEqual(1000, Tools.Memory.ConvertMemoryMetric(1, MemoryMetric.Kilobyte, MemoryMetric.Byte)); + ClassicAssert.AreEqual(1000, Tools.Memory.ConvertMemoryMetric(1, MemoryMetric.Kilobyte, MemoryMetric.Byte)); } [Test] public void Byte2Kilobyte() { - Assert.AreEqual(1, Tools.Memory.ConvertMemoryMetric(1000, MemoryMetric.Byte, MemoryMetric.Kilobyte)); + ClassicAssert.AreEqual(1, Tools.Memory.ConvertMemoryMetric(1000, MemoryMetric.Byte, MemoryMetric.Kilobyte)); } [Test] public void KilobyteToMegabyte() { - Assert.AreEqual(1, Tools.Memory.ConvertMemoryMetric(1000, MemoryMetric.Kilobyte, MemoryMetric.Megabyte)); + ClassicAssert.AreEqual(1, Tools.Memory.ConvertMemoryMetric(1000, MemoryMetric.Kilobyte, MemoryMetric.Megabyte)); } [Test] public void KilobyteToMegabit() { - Assert.AreEqual(1 * 8, Tools.Memory.ConvertMemoryMetric(1000, MemoryMetric.Kilobyte, MemoryMetric.Megabit)); + ClassicAssert.AreEqual(1 * 8, Tools.Memory.ConvertMemoryMetric(1000, MemoryMetric.Kilobyte, MemoryMetric.Megabit)); } } diff --git a/tests/Hydrogen.Tests/Merkle/FlatMerkleTreeTests.cs b/tests/Hydrogen.Tests/Merkle/FlatMerkleTreeTests.cs index 37cecc4fd..db3e2b5ba 100644 --- a/tests/Hydrogen.Tests/Merkle/FlatMerkleTreeTests.cs +++ b/tests/Hydrogen.Tests/Merkle/FlatMerkleTreeTests.cs @@ -12,6 +12,7 @@ using System.Linq; using Hydrogen.NUnit; using Hydrogen; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests.Merkle; @@ -24,13 +25,13 @@ public void Integration_AddRange_Single([Values(CHF.SHA2_256)] CHF chf) { var rng = new Random(31337); var reference = new SimpleMerkleTree(chf); var impl = new FlatMerkleTree(chf); - Assert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(reference.Root, impl.Root); var newItems = rng.NextBytes(Hashers.GetDigestSizeBytes(chf)); reference.Leafs.AddRange(newItems); impl.Leafs.AddRange(newItems); - Assert.AreEqual(reference.Root, impl.Root); - Assert.AreEqual(reference.Leafs.Count, impl.Leafs.Count); - Assert.AreEqual(reference.Size, impl.Size); + ClassicAssert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(reference.Leafs.Count, impl.Leafs.Count); + ClassicAssert.AreEqual(reference.Size, impl.Size); } [Test] @@ -43,8 +44,8 @@ public void Integration_AddRange_Simple([Values(CHF.SHA2_256)] CHF chf) { var newItems = rng.NextBytes(Hashers.GetDigestSizeBytes(chf)); reference.Leafs.AddRange(newItems); impl.Leafs.AddRange(newItems); - Assert.AreEqual(reference.Root, impl.Root); - Assert.AreEqual(impl.Leafs.Count, impl.Size.LeafCount); + ClassicAssert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(impl.Leafs.Count, impl.Size.LeafCount); } } @@ -57,7 +58,7 @@ public void Integration_AddRange_Complex([Values(CHF.SHA2_256)] CHF chf) { var rng = new Random(31337); var reference = new SimpleMerkleTree(chf); var impl = new FlatMerkleTree(chf); - Assert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(reference.Root, impl.Root); for (var i = 0; i < MaxIterations; i++) { var newItems = Tools.Collection.Generate(() => rng.NextBytes(Hashers.GetDigestSizeBytes(chf))).Take(rng.Next(MinItemsAddPerIter, MaxItemsAddPerIter + 1)).ToArray(); @@ -65,12 +66,12 @@ public void Integration_AddRange_Complex([Values(CHF.SHA2_256)] CHF chf) { reference.Leafs.AddRange(newItems); impl.Leafs.AddRange(newItems); if (Tools.Maths.Gamble(0.1)) // force root calculation 10% of the time - Assert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(reference.Root, impl.Root); - Assert.AreEqual(impl.Leafs.Count, impl.Size.LeafCount); + ClassicAssert.AreEqual(impl.Leafs.Count, impl.Size.LeafCount); } - Assert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(reference.Root, impl.Root); } [Test] @@ -163,7 +164,7 @@ public void Insert_1() { var digest = rng.NextByteArrays(Hashers.GetDigestSizeBytes(CHF.SHA2_256), 1)[0]; expected.Insert(0, digest); list.Leafs.Insert(0, digest); - Assert.AreEqual(expected.ToArray(), list.Leafs.ToArray()); + ClassicAssert.AreEqual(expected.ToArray(), list.Leafs.ToArray()); } [Test] @@ -179,7 +180,7 @@ public void Insert_2() { expected.Insert(0, digest[1]); list.Leafs.Insert(0, digest[1]); - Assert.AreEqual(expected.ToArray(), list.Leafs.ToArray()); + ClassicAssert.AreEqual(expected.ToArray(), list.Leafs.ToArray()); } [Test] @@ -198,7 +199,7 @@ public void Insert_3() { expected.Insert(1, digest[1]); list.Leafs.Insert(1, digest[1]); - Assert.AreEqual(expected.ToArray(), list.Leafs.ToArray()); + ClassicAssert.AreEqual(expected.ToArray(), list.Leafs.ToArray()); } [Test] @@ -214,7 +215,7 @@ public void RemoveAt_1([Values(3, 4)] int leafCount) { expected.RemoveAt(1); list.Leafs.RemoveAt(1); - Assert.AreEqual(expected.ToArray(), list.Leafs.ToArray()); + ClassicAssert.AreEqual(expected.ToArray(), list.Leafs.ToArray()); } @@ -231,7 +232,7 @@ public void RemoveAt_2([Values(3, 4)] int leafCount) { expected.RemoveAt(2); list.Leafs.RemoveAt(2); - Assert.AreEqual(expected.ToArray(), list.Leafs.ToArray()); + ClassicAssert.AreEqual(expected.ToArray(), list.Leafs.ToArray()); } [Test] @@ -247,7 +248,7 @@ public void TestNodes_BottomUp( for (var j = 0; j < MerkleMath.CalculateLevelLength(leafCount, i); j++) { var e = expected.GetValue(MerkleCoordinate.From(i, j)).ToArray(); var a = actual.GetValue(MerkleCoordinate.From(i, j)).ToArray(); - Assert.AreEqual(e, a); + ClassicAssert.AreEqual(e, a); } } } @@ -265,7 +266,7 @@ public void TestNodes_TopDown( for (var j = MerkleMath.CalculateLevelLength(leafCount, i) - 1; j >= 0; j--) { var e = expected.GetValue(MerkleCoordinate.From(i, j)).ToArray(); var a = actual.GetValue(MerkleCoordinate.From(i, j)).ToArray(); - Assert.AreEqual(e, a); + ClassicAssert.AreEqual(e, a); } } } diff --git a/tests/Hydrogen.Tests/Merkle/LongMerkleTreeTests.cs b/tests/Hydrogen.Tests/Merkle/LongMerkleTreeTests.cs index b727d69ab..d7693e33e 100644 --- a/tests/Hydrogen.Tests/Merkle/LongMerkleTreeTests.cs +++ b/tests/Hydrogen.Tests/Merkle/LongMerkleTreeTests.cs @@ -10,6 +10,7 @@ using NUnit.Framework; using System.Linq; using Hydrogen; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests.Merkle; @@ -22,13 +23,13 @@ public void Integration_AddRange_Single([Values(CHF.SHA2_256)] CHF chf) { var rng = new Random(31337); var reference = new SimpleMerkleTree(chf); var impl = new LongMerkleTree(chf); - Assert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(reference.Root, impl.Root); var newItems = rng.NextBytes(Hashers.GetDigestSizeBytes(chf)); reference.Leafs.AddRange(newItems); impl.Leafs.AddRange(newItems); - Assert.AreEqual(reference.Root, impl.Root); - Assert.AreEqual(reference.Leafs.Count, impl.Leafs.Count); - Assert.AreEqual(reference.Size, impl.Size); + ClassicAssert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(reference.Leafs.Count, impl.Leafs.Count); + ClassicAssert.AreEqual(reference.Size, impl.Size); } [Test] @@ -41,8 +42,8 @@ public void Integration_AddRange_Simple([Values(CHF.SHA2_256)] CHF chf) { var newItems = rng.NextBytes(Hashers.GetDigestSizeBytes(chf)); reference.Leafs.AddRange(newItems); impl.Leafs.AddRange(newItems); - Assert.AreEqual(reference.Root, impl.Root); - Assert.AreEqual(impl.Leafs.Count, impl.Size.LeafCount); + ClassicAssert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(impl.Leafs.Count, impl.Size.LeafCount); } } @@ -55,7 +56,7 @@ public void Integration_AddRange_Complex([Values(CHF.SHA2_256)] CHF chf) { var rng = new Random(31337); var reference = new SimpleMerkleTree(chf); var impl = new LongMerkleTree(chf); - Assert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(reference.Root, impl.Root); for (var i = 0; i < MaxIterations; i++) { var newItems = Tools.Collection.Generate(() => rng.NextBytes(Hashers.GetDigestSizeBytes(chf))).Take(rng.Next(MinItemsAddPerIter, MaxItemsAddPerIter + 1)).ToArray(); @@ -63,12 +64,12 @@ public void Integration_AddRange_Complex([Values(CHF.SHA2_256)] CHF chf) { reference.Leafs.AddRange(newItems); impl.Leafs.AddRange(newItems); if (Tools.Maths.Gamble(0.1)) // force root calculation 10% of the time - Assert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(reference.Root, impl.Root); - Assert.AreEqual(impl.Leafs.Count, impl.Size.LeafCount); + ClassicAssert.AreEqual(impl.Leafs.Count, impl.Size.LeafCount); } - Assert.AreEqual(reference.Root, impl.Root); + ClassicAssert.AreEqual(reference.Root, impl.Root); } [Test] diff --git a/tests/Hydrogen.Tests/Merkle/MerkleMathTests.cs b/tests/Hydrogen.Tests/Merkle/MerkleMathTests.cs index 597f69f61..b37a63643 100644 --- a/tests/Hydrogen.Tests/Merkle/MerkleMathTests.cs +++ b/tests/Hydrogen.Tests/Merkle/MerkleMathTests.cs @@ -9,6 +9,7 @@ using System.Collections.Generic; using NUnit.Framework; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests.Merkle; @@ -38,18 +39,18 @@ private static int[] CalculateTreeDimensionsManual(int leafCount) { [Test] public void IsPerfect() { for (var x = 0; x < 31; x++) { - Assert.IsTrue(MerkleMath.IsPerfectTree(MerkleSize.FromLeafCount(1 << x))); + ClassicAssert.IsTrue(MerkleMath.IsPerfectTree(MerkleSize.FromLeafCount(1 << x))); if (x != 1) - Assert.IsFalse(MerkleMath.IsPerfectTree(MerkleSize.FromLeafCount((1 << x) - 1))); + ClassicAssert.IsFalse(MerkleMath.IsPerfectTree(MerkleSize.FromLeafCount((1 << x) - 1))); } } [Test] public void CalculateHeight_Basic() { - Assert.AreEqual(0, MerkleMath.CalculateHeight(0)); - Assert.AreEqual(1, MerkleMath.CalculateHeight(1)); - Assert.AreEqual(3, MerkleMath.CalculateHeight(3)); - Assert.AreEqual(32, MerkleMath.CalculateHeight(int.MaxValue)); + ClassicAssert.AreEqual(0, MerkleMath.CalculateHeight(0)); + ClassicAssert.AreEqual(1, MerkleMath.CalculateHeight(1)); + ClassicAssert.AreEqual(3, MerkleMath.CalculateHeight(3)); + ClassicAssert.AreEqual(32, MerkleMath.CalculateHeight(int.MaxValue)); } [Test] @@ -62,7 +63,7 @@ public void CalculateHeight_Consistent() { var height = MerkleMath.CalculateHeight(leafCount); var dims = CalculateTreeDimensionsManual(leafCount); - Assert.AreEqual(dims.Length, height); + ClassicAssert.AreEqual(dims.Length, height); } } } @@ -82,7 +83,7 @@ public void CalculateLevelLength_Consistent() { if (k == 31 && leafCount == int.MaxValue) { var xxx = 1; } - Assert.AreEqual(dims[k], MerkleMath.CalculateLevelLength(treeSize.LeafCount, k)); + ClassicAssert.AreEqual(dims[k], MerkleMath.CalculateLevelLength(treeSize.LeafCount, k)); } } } @@ -104,9 +105,9 @@ public void CalculateHeight_Length_RandomSamples() { var dims = CalculateTreeDimensionsManual(leafCount); // note: CalculateTreeDimensions is simple integer based arithmetic var treeSize = MerkleSize.FromLeafCount(leafCount); - Assert.AreEqual(dims.Length, MerkleMath.CalculateHeight(leafCount)); + ClassicAssert.AreEqual(dims.Length, MerkleMath.CalculateHeight(leafCount)); for (var j = 0; j < dims.Length; j++) { - Assert.AreEqual(dims[j], MerkleMath.CalculateLevelLength(treeSize.LeafCount, j)); + ClassicAssert.AreEqual(dims[j], MerkleMath.CalculateLevelLength(treeSize.LeafCount, j)); } } } @@ -114,7 +115,7 @@ public void CalculateHeight_Length_RandomSamples() { [Test] public void CalculateNodeTraits_Single() { var size = MerkleSize.FromLeafCount(1); - Assert.AreEqual(1, size.Height); + ClassicAssert.AreEqual(1, size.Height); var traits = MerkleMath.GetTraits(size, MerkleCoordinate.LeafAt(0)); AssertEx.HasFlags(MerkleNodeTraits.Root, traits); AssertEx.HasFlags(MerkleNodeTraits.Leaf, traits); @@ -215,7 +216,7 @@ public void CalculateNodeTraits_LargePerfectTree() { public void CalculateNodeTraits_Root_1() { var size = MerkleSize.FromLeafCount(1); // T - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Root)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Root)); } [Test] @@ -296,7 +297,7 @@ public void CalculateNodeTraits_Perfect_1() { var size = MerkleSize.FromLeafCount(1); // T - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Perfect)); } [Test] @@ -307,12 +308,12 @@ public void CalculateNodeTraits_Perfect_4() { // T T // T T T T - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 2)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 2)).HasFlag(MerkleNodeTraits.Perfect)); } [Test] @@ -323,17 +324,17 @@ public void CalculateNodeTraits_Perfect_5() { // T T F // T T T T T - Assert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(3, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 2)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 2)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 3)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 4)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(3, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 2)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 2)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 3)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 4)).HasFlag(MerkleNodeTraits.Perfect)); } @@ -345,22 +346,22 @@ public void CalculateNodeTraits_Perfect_6() { // T T T // T T T T T T - Assert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(3, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(3, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 2)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 2)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 2)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 3)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 4)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 5)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 2)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 3)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 4)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 5)).HasFlag(MerkleNodeTraits.Perfect)); } @@ -372,23 +373,23 @@ public void CalculateNodeTraits_Perfect_7() { // T T T F // T T T T T T T - Assert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(3, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(3, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(2, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 2)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 3)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 2)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsFalse(MerkleMath.GetTraits(size, MerkleCoordinate.From(1, 3)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 1)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 2)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 3)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 4)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 5)).HasFlag(MerkleNodeTraits.Perfect)); - Assert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 6)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 0)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 1)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 2)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 3)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 4)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 5)).HasFlag(MerkleNodeTraits.Perfect)); + ClassicAssert.IsTrue(MerkleMath.GetTraits(size, MerkleCoordinate.From(0, 6)).HasFlag(MerkleNodeTraits.Perfect)); } @@ -409,55 +410,55 @@ public void GetChildren_3() { var (left, right) = MerkleMath.GetChildren(size, a); - Assert.AreEqual(b, left); - Assert.AreEqual(c, right); + ClassicAssert.AreEqual(b, left); + ClassicAssert.AreEqual(c, right); (left, right) = MerkleMath.GetChildren(size, b); - Assert.AreEqual(d, left); - Assert.AreEqual(e, right); + ClassicAssert.AreEqual(d, left); + ClassicAssert.AreEqual(e, right); (left, right) = MerkleMath.GetChildren(size, c); - Assert.AreEqual(f, left); - Assert.AreEqual(MerkleCoordinate.Null, right); + ClassicAssert.AreEqual(f, left); + ClassicAssert.AreEqual(MerkleCoordinate.Null, right); } [Test] public void FromFlatCoordinate() { - Assert.AreEqual(MerkleCoordinate.From(0, 0), MerkleMath.FromFlatIndex(0)); - Assert.AreEqual(MerkleCoordinate.From(0, 1), MerkleMath.FromFlatIndex(1)); - Assert.AreEqual(MerkleCoordinate.From(1, 0), MerkleMath.FromFlatIndex(2)); - Assert.AreEqual(MerkleCoordinate.From(0, 2), MerkleMath.FromFlatIndex(3)); - Assert.AreEqual(MerkleCoordinate.From(0, 3), MerkleMath.FromFlatIndex(4)); - Assert.AreEqual(MerkleCoordinate.From(1, 1), MerkleMath.FromFlatIndex(5)); - Assert.AreEqual(MerkleCoordinate.From(2, 0), MerkleMath.FromFlatIndex(6)); - Assert.AreEqual(MerkleCoordinate.From(0, 4), MerkleMath.FromFlatIndex(7)); - Assert.AreEqual(MerkleCoordinate.From(0, 5), MerkleMath.FromFlatIndex(8)); - Assert.AreEqual(MerkleCoordinate.From(1, 2), MerkleMath.FromFlatIndex(9)); - Assert.AreEqual(MerkleCoordinate.From(0, 6), MerkleMath.FromFlatIndex(10)); - Assert.AreEqual(MerkleCoordinate.From(0, 7), MerkleMath.FromFlatIndex(11)); - Assert.AreEqual(MerkleCoordinate.From(1, 3), MerkleMath.FromFlatIndex(12)); - Assert.AreEqual(MerkleCoordinate.From(2, 1), MerkleMath.FromFlatIndex(13)); - Assert.AreEqual(MerkleCoordinate.From(3, 0), MerkleMath.FromFlatIndex(14)); + ClassicAssert.AreEqual(MerkleCoordinate.From(0, 0), MerkleMath.FromFlatIndex(0)); + ClassicAssert.AreEqual(MerkleCoordinate.From(0, 1), MerkleMath.FromFlatIndex(1)); + ClassicAssert.AreEqual(MerkleCoordinate.From(1, 0), MerkleMath.FromFlatIndex(2)); + ClassicAssert.AreEqual(MerkleCoordinate.From(0, 2), MerkleMath.FromFlatIndex(3)); + ClassicAssert.AreEqual(MerkleCoordinate.From(0, 3), MerkleMath.FromFlatIndex(4)); + ClassicAssert.AreEqual(MerkleCoordinate.From(1, 1), MerkleMath.FromFlatIndex(5)); + ClassicAssert.AreEqual(MerkleCoordinate.From(2, 0), MerkleMath.FromFlatIndex(6)); + ClassicAssert.AreEqual(MerkleCoordinate.From(0, 4), MerkleMath.FromFlatIndex(7)); + ClassicAssert.AreEqual(MerkleCoordinate.From(0, 5), MerkleMath.FromFlatIndex(8)); + ClassicAssert.AreEqual(MerkleCoordinate.From(1, 2), MerkleMath.FromFlatIndex(9)); + ClassicAssert.AreEqual(MerkleCoordinate.From(0, 6), MerkleMath.FromFlatIndex(10)); + ClassicAssert.AreEqual(MerkleCoordinate.From(0, 7), MerkleMath.FromFlatIndex(11)); + ClassicAssert.AreEqual(MerkleCoordinate.From(1, 3), MerkleMath.FromFlatIndex(12)); + ClassicAssert.AreEqual(MerkleCoordinate.From(2, 1), MerkleMath.FromFlatIndex(13)); + ClassicAssert.AreEqual(MerkleCoordinate.From(3, 0), MerkleMath.FromFlatIndex(14)); } [Test] public void ToFlatCoordinate() { - Assert.AreEqual(0, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 0))); - Assert.AreEqual(1, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 1))); - Assert.AreEqual(2, MerkleMath.ToFlatIndex(MerkleCoordinate.From(1, 0))); - Assert.AreEqual(3, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 2))); - Assert.AreEqual(4, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 3))); - Assert.AreEqual(5, MerkleMath.ToFlatIndex(MerkleCoordinate.From(1, 1))); - Assert.AreEqual(6, MerkleMath.ToFlatIndex(MerkleCoordinate.From(2, 0))); - Assert.AreEqual(7, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 4))); - Assert.AreEqual(8, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 5))); - Assert.AreEqual(9, MerkleMath.ToFlatIndex(MerkleCoordinate.From(1, 2))); - Assert.AreEqual(10, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 6))); - Assert.AreEqual(11, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 7))); - Assert.AreEqual(12, MerkleMath.ToFlatIndex(MerkleCoordinate.From(1, 3))); - Assert.AreEqual(13, MerkleMath.ToFlatIndex(MerkleCoordinate.From(2, 1))); - Assert.AreEqual(14, MerkleMath.ToFlatIndex(MerkleCoordinate.From(3, 0))); + ClassicAssert.AreEqual(0, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 0))); + ClassicAssert.AreEqual(1, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 1))); + ClassicAssert.AreEqual(2, MerkleMath.ToFlatIndex(MerkleCoordinate.From(1, 0))); + ClassicAssert.AreEqual(3, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 2))); + ClassicAssert.AreEqual(4, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 3))); + ClassicAssert.AreEqual(5, MerkleMath.ToFlatIndex(MerkleCoordinate.From(1, 1))); + ClassicAssert.AreEqual(6, MerkleMath.ToFlatIndex(MerkleCoordinate.From(2, 0))); + ClassicAssert.AreEqual(7, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 4))); + ClassicAssert.AreEqual(8, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 5))); + ClassicAssert.AreEqual(9, MerkleMath.ToFlatIndex(MerkleCoordinate.From(1, 2))); + ClassicAssert.AreEqual(10, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 6))); + ClassicAssert.AreEqual(11, MerkleMath.ToFlatIndex(MerkleCoordinate.From(0, 7))); + ClassicAssert.AreEqual(12, MerkleMath.ToFlatIndex(MerkleCoordinate.From(1, 3))); + ClassicAssert.AreEqual(13, MerkleMath.ToFlatIndex(MerkleCoordinate.From(2, 1))); + ClassicAssert.AreEqual(14, MerkleMath.ToFlatIndex(MerkleCoordinate.From(3, 0))); } [Test] @@ -466,7 +467,7 @@ public void FlatCoordinate_Consistency() { for (var i = 0UL; i < Max; i++) { var coord = MerkleMath.FromFlatIndex(i); var result = MerkleMath.ToFlatIndex(coord); - Assert.AreEqual(i, result); + ClassicAssert.AreEqual(i, result); } } @@ -476,7 +477,7 @@ public void FlatCoordinate_Uniqueness() { var set = new HashSet(); for (var i = 0UL; i < Max; i++) { var coord = MerkleMath.FromFlatIndex(i); - Assert.IsFalse(set.Contains(coord)); + ClassicAssert.IsFalse(set.Contains(coord)); set.Add(coord); } } diff --git a/tests/Hydrogen.Tests/Merkle/MerkleProofTests.cs b/tests/Hydrogen.Tests/Merkle/MerkleProofTests.cs index 45c78b819..53b82310f 100644 --- a/tests/Hydrogen.Tests/Merkle/MerkleProofTests.cs +++ b/tests/Hydrogen.Tests/Merkle/MerkleProofTests.cs @@ -11,6 +11,7 @@ using System.Linq; using System.Text; using Hydrogen; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests.Merkle; @@ -28,16 +29,16 @@ public void ExistenceProof() { for (var i = 0; i < tree.Leafs.Count; i++) { var proof = tree.GenerateExistenceProof(i).ToArray(); var verify = MerkleMath.VerifyExistenceProof(tree.HashAlgorithm, tree.Root, tree.Size, i, Encoding.ASCII.GetBytes(elems[i]), proof); - Assert.IsTrue(verify); + ClassicAssert.IsTrue(verify); } } // Verify last proof items var lastProof = tree.GenerateExistenceProof(tree.Leafs.Count - 1).ToArray(); - Assert.AreEqual(3, lastProof.Length); - Assert.AreEqual(lastProof[0], Encoding.ASCII.GetBytes("Y")); - Assert.AreEqual(lastProof[1], Encoding.ASCII.GetBytes("QRSTUVWX")); - Assert.AreEqual(lastProof[2], Encoding.ASCII.GetBytes("ABCDEFGHIJKLMNOP")); + ClassicAssert.AreEqual(3, lastProof.Length); + ClassicAssert.AreEqual(lastProof[0], Encoding.ASCII.GetBytes("Y")); + ClassicAssert.AreEqual(lastProof[1], Encoding.ASCII.GetBytes("QRSTUVWX")); + ClassicAssert.AreEqual(lastProof[2], Encoding.ASCII.GetBytes("ABCDEFGHIJKLMNOP")); } @@ -61,7 +62,7 @@ public void ConsistencyProof([Values(CHF.ConcatBytes, CHF.SHA2_256)] CHF chf) { var consistencyProof = newTree.GenerateConsistencyProof(i); var verifyProof = MerkleMath.VerifyConsistencyProof(chf, oldTree.Root, i, newTree.Root, i + (j - i), consistencyProof); - Assert.IsTrue(verifyProof); + ClassicAssert.IsTrue(verifyProof); } } diff --git a/tests/Hydrogen.Tests/Merkle/MerkleTreeTests.cs b/tests/Hydrogen.Tests/Merkle/MerkleTreeTests.cs index 52f6257db..2bb4bdd0d 100644 --- a/tests/Hydrogen.Tests/Merkle/MerkleTreeTests.cs +++ b/tests/Hydrogen.Tests/Merkle/MerkleTreeTests.cs @@ -12,6 +12,7 @@ using System.Linq; using System.Text; using Hydrogen; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests.Merkle; @@ -25,8 +26,8 @@ public void NullRoot( [Values(MerkleTreeImpl.Simple, MerkleTreeImpl.Flat, MerkleTreeImpl.Long)] MerkleTreeImpl impl) { var tree = CreateMerkleTree(impl, chf); - Assert.AreEqual(MerkleSize.FromLeafCount(0), tree.Size); - Assert.AreEqual(null, tree.Root); + ClassicAssert.AreEqual(MerkleSize.FromLeafCount(0), tree.Size); + ClassicAssert.AreEqual(null, tree.Root); } [Test] @@ -38,7 +39,7 @@ public void SingleRoot( var tree = CreateMerkleTree(impl, chf); var data = rng.NextByteArrays(Hashers.GetDigestSizeBytes(chf), 1)[0]; tree.Leafs.Add(data); - Assert.AreEqual(data, tree.Root); + ClassicAssert.AreEqual(data, tree.Root); } [Test] @@ -57,7 +58,7 @@ public void PastRoots( } for (var i = 0; i < Items; i++) { - Assert.AreEqual(roots[i], tree.CalculateOldRoot(i + 1)); + ClassicAssert.AreEqual(roots[i], tree.CalculateOldRoot(i + 1)); } } @@ -70,13 +71,13 @@ public void Update_1( var rng = new Random(31337); // add item tree.Leafs.Add(Hashers.Hash(chf, rng.NextBytes(100))); - Assert.AreEqual(tree.Leafs[0], tree.Root); + ClassicAssert.AreEqual(tree.Leafs[0], tree.Root); // update it var datum = Hashers.Hash(chf, rng.NextBytes(100)); tree.Leafs.Update(0, datum); - Assert.AreEqual(datum, tree.Leafs[0]); - Assert.AreEqual(datum, tree.Root); + ClassicAssert.AreEqual(datum, tree.Leafs[0]); + ClassicAssert.AreEqual(datum, tree.Root); } [Test] @@ -92,7 +93,7 @@ public void ExistenceProof_2( tree.Leafs.Add(elem); for (var i = 0; i < tree.Leafs.Count; i++) { var proof = tree.GenerateExistenceProof(i).ToArray(); - Assert.IsTrue(MerkleMath.VerifyExistenceProof(chf, tree.Root, tree.Size, i, elemsHash[i], proof)); + ClassicAssert.IsTrue(MerkleMath.VerifyExistenceProof(chf, tree.Root, tree.Size, i, elemsHash[i], proof)); } } @@ -122,7 +123,7 @@ public void ConsistencyProof( var consistencyProof = newTree.GenerateConsistencyProof(i); var verifyProof = MerkleMath.VerifyConsistencyProof(chf, oldTree.Root, i, newTree.Root, i + (j - i), consistencyProof); - Assert.IsTrue(verifyProof); + ClassicAssert.IsTrue(verifyProof); } } } @@ -146,7 +147,7 @@ public void ContainsProof_Range( var proof = tree.GenerateContainsProof(i, j - i); var verify = MerkleMath.VerifyContainsProof(chf, tree.Root, tree.Size, i, leafs, proof); - Assert.IsTrue(verify); + ClassicAssert.IsTrue(verify); } } } @@ -169,7 +170,7 @@ public void ContainsProof_Random( var leafs = indices.Select(i => elems[i]).ToArray(); var proof = tree.GenerateContainsProof(indices); var verify = MerkleMath.VerifyContainsProof(chf, tree.Root, tree.Size, indices.Zip(leafs, Tuple.Create), proof); - Assert.IsTrue(verify); + ClassicAssert.IsTrue(verify); } } @@ -200,7 +201,7 @@ public void UpdateProof_Range( var updateProof = oldTree.GenerateUpdateProof(i, j - i); var verifyProof = MerkleMath.VerifyUpdateProof(chf, oldTree.Root, oldTree.Size, newRoot, i, updatedItems, updateProof); - Assert.IsTrue(verifyProof); + ClassicAssert.IsTrue(verifyProof); } } } @@ -230,7 +231,7 @@ public void UpdateProof_Random( // Gen proof var updateProof = oldTree.GenerateUpdateProof(indices); var verifyProof = MerkleMath.VerifyUpdateProof(chf, oldTree.Root, oldTree.Size, newTree.Root, indices.Zip(newLeafs), updateProof); - Assert.IsTrue(verifyProof); + ClassicAssert.IsTrue(verifyProof); } } @@ -256,7 +257,7 @@ public void AppendProof( // Gen proof var appendProof = oldTree.GenerateAppendProof(); var verifyProof = MerkleMath.VerifyAppendProof(chf, oldTree.Root, newTree.Root, oldTree.Size, newLeafs, appendProof); - Assert.IsTrue(verifyProof); + ClassicAssert.IsTrue(verifyProof); } [Test] @@ -280,7 +281,7 @@ public void DeleteProof( var deleteProof = oldTree.GenerateDeleteProof(i); newTree.Leafs.RemoveRange(newTree.Leafs.Count - i, i); var verifyProof = MerkleMath.VerifyDeleteProof(chf, oldTree.Root, leafCount, newTree.Root, i, deleteProof); - Assert.IsTrue(verifyProof); + ClassicAssert.IsTrue(verifyProof); } } diff --git a/tests/Hydrogen.Tests/Merkle/SimpleMerkleTreeTests.cs b/tests/Hydrogen.Tests/Merkle/SimpleMerkleTreeTests.cs index 44d92771e..b2cc6e07c 100644 --- a/tests/Hydrogen.Tests/Merkle/SimpleMerkleTreeTests.cs +++ b/tests/Hydrogen.Tests/Merkle/SimpleMerkleTreeTests.cs @@ -11,6 +11,7 @@ using System.Linq; using System.Text; using Hydrogen; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests.Merkle; @@ -29,7 +30,7 @@ public void Add() { foreach (var (newLeaf, expectedTree) in new string[] { null }.Concat(elems).Zip(expectedTrees, Tuple.Create)) { if (newLeaf != null) testTree.Leafs.Add(Encoding.ASCII.GetBytes(newLeaf)); - Assert.AreEqual(expectedTree.Root, testTree.Root); + ClassicAssert.AreEqual(expectedTree.Root, testTree.Root); } } @@ -37,27 +38,27 @@ public void Add() { public void Insert() { var expected = new SimpleMerkleTree(CHF.ConcatBytes, new[] { "A", "B", "C", "D", "E", "F", "G", "H", "I" }.Select(Encoding.ASCII.GetBytes)); var test = new SimpleMerkleTree(CHF.ConcatBytes, new[] { "A", "B", "C", "G", "H", "I" }.Select(Encoding.ASCII.GetBytes)); - Assert.AreNotEqual(expected.Root, test.Root); + ClassicAssert.AreNotEqual(expected.Root, test.Root); test.Leafs.InsertRange(3, new[] { "D", "E", "F" }.Select(Encoding.ASCII.GetBytes)); - Assert.AreEqual(expected.Root, test.Root); + ClassicAssert.AreEqual(expected.Root, test.Root); } [Test] public void Update() { var expected = new SimpleMerkleTree(CHF.ConcatBytes, new[] { "A", "B", "C", "D", "E", "F", "G", "H", "I" }.Select(Encoding.ASCII.GetBytes)); var test = new SimpleMerkleTree(CHF.ConcatBytes, new[] { "A", "B", "C", "Z", "Z", "Z", "G", "H", "I" }.Select(Encoding.ASCII.GetBytes)); - Assert.AreNotEqual(expected.Root, test.Root); + ClassicAssert.AreNotEqual(expected.Root, test.Root); test.Leafs.UpdateRange(3, new[] { "D", "E", "F" }.Select(Encoding.ASCII.GetBytes)); - Assert.AreEqual(expected.Root, test.Root); + ClassicAssert.AreEqual(expected.Root, test.Root); } [Test] public void Remove() { var expected = new SimpleMerkleTree(CHF.ConcatBytes, new[] { "A", "B", "C", "G", "H", "I" }.Select(Encoding.ASCII.GetBytes)); var test = new SimpleMerkleTree(CHF.ConcatBytes, new[] { "A", "B", "C", "D", "E", "F", "G", "H", "I" }.Select(Encoding.ASCII.GetBytes)); - Assert.AreNotEqual(expected.Root, test.Root); + ClassicAssert.AreNotEqual(expected.Root, test.Root); test.Leafs.RemoveRange(3, 3); - Assert.AreEqual(expected.Root, test.Root); + ClassicAssert.AreEqual(expected.Root, test.Root); } } diff --git a/tests/Hydrogen.Tests/Misc/BitsTests.cs b/tests/Hydrogen.Tests/Misc/BitsTests.cs index 523668257..d99f4b6cf 100644 --- a/tests/Hydrogen.Tests/Misc/BitsTests.cs +++ b/tests/Hydrogen.Tests/Misc/BitsTests.cs @@ -9,6 +9,7 @@ using System; using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -23,7 +24,7 @@ public void CopyBits_L2R() { var dest = new byte[100]; var bitLength = bytes.Length * 8; Bits.CopyBits(bytes, 0, dest, 0, bitLength); - Assert.AreEqual(bytes, dest); + ClassicAssert.AreEqual(bytes, dest); } [Test] @@ -33,7 +34,7 @@ public void CopyBits_R2L() { var dest = new byte[100]; var bitLength = bytes.Length * 8; Bits.CopyBits(bytes, bitLength - 1, dest, bitLength - 1, bitLength, IterateDirection.RightToLeft, IterateDirection.RightToLeft); - Assert.AreEqual(bytes, dest); + ClassicAssert.AreEqual(bytes, dest); } @@ -46,7 +47,7 @@ public void CopyBits_Integration_1() { var bitLength = bytes.Length * 8; Bits.CopyBits(bytes, 0, tmp, bitLength - 1, bitLength, IterateDirection.LeftToRight, IterateDirection.RightToLeft); Bits.CopyBits(tmp, bitLength - 1, dest, 0, bitLength, IterateDirection.RightToLeft, IterateDirection.LeftToRight); - Assert.AreEqual(bytes, dest); + ClassicAssert.AreEqual(bytes, dest); } [Test] @@ -56,8 +57,8 @@ public void SetBit_1() { Bits.SetBit(buffer, 7, true); Bits.SetBit(buffer, 15, true); - Assert.AreEqual(1, buffer[0]); - Assert.AreEqual(1, buffer[1]); + ClassicAssert.AreEqual(1, buffer[0]); + ClassicAssert.AreEqual(1, buffer[1]); } [Test] @@ -69,31 +70,31 @@ public void SetBit_2() { Bits.SetBit(buffer, 8, false); Bits.SetBit(buffer, 15, true); - Assert.AreEqual(128, buffer[0]); - Assert.AreEqual(1, buffer[1]); + ClassicAssert.AreEqual(128, buffer[0]); + ClassicAssert.AreEqual(1, buffer[1]); } [Test] public void SetBit_3() { var buffer = new byte[1]; Bits.SetBit(buffer, 0, true); - Assert.AreEqual(128, (int)buffer[0]); + ClassicAssert.AreEqual(128, (int)buffer[0]); } [Test] public void ReadBit_1() { var buffer = new byte[] { 129, 128, 255 }; - Assert.True(Bits.ReadBit(buffer, 0)); - Assert.True(Bits.ReadBit(buffer, 7)); - Assert.True(Bits.ReadBit(buffer, 8)); - Assert.False(Bits.ReadBit(buffer, 15)); + ClassicAssert.IsTrue(Bits.ReadBit(buffer, 0)); + ClassicAssert.IsTrue(Bits.ReadBit(buffer, 7)); + ClassicAssert.IsTrue(Bits.ReadBit(buffer, 8)); + ClassicAssert.IsFalse(Bits.ReadBit(buffer, 15)); bool allTrue = Enumerable.Range(16, 7) .Select(x => Bits.ReadBit(buffer, x)) .All(x => x); - Assert.True(allTrue); + ClassicAssert.IsTrue(allTrue); } [Test] @@ -115,7 +116,7 @@ public void CopyBits_Integration_2() { Bits.CopyBits(arr2, range.Start, arr1, range.Start, range.End - range.Start + 1, dir, dir); } - Assert.AreEqual(arr1, arr2); + ClassicAssert.AreEqual(arr1, arr2); } } @@ -137,7 +138,7 @@ public void ReadWriteNumber_Integration_1() { var number = Bits.ReadBinaryNumber(bytes, offset, bitsInNumber, dir); // Check not bigger than possible (this can happen if reading bits wrong) - Assert.LessOrEqual(number, 1 << bitsInNumber); + ClassicAssert.LessOrEqual(number, 1 << bitsInNumber); // Rebuild the array copy surrounding bits and writing the number where it was read var copy = new byte[bytes.Length]; //Tools.Array.Clone(bytes); @@ -146,7 +147,7 @@ public void ReadWriteNumber_Integration_1() { Bits.WriteBinaryNumber(number, copy, offset, bitsInNumber, dir); // Check unchanged - Assert.AreEqual(bytes, copy); + ClassicAssert.AreEqual(bytes, copy); } } diff --git a/tests/Hydrogen.Tests/Misc/MiscellaneousTests.cs b/tests/Hydrogen.Tests/Misc/MiscellaneousTests.cs index b6486aaa6..51a5a6502 100644 --- a/tests/Hydrogen.Tests/Misc/MiscellaneousTests.cs +++ b/tests/Hydrogen.Tests/Misc/MiscellaneousTests.cs @@ -13,6 +13,7 @@ using System.Threading; using System.Threading.Tasks; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -23,7 +24,7 @@ public class MiscellaneousTests { [Test] public void InterpolateNullAssumption() { - Assert.AreEqual(string.Empty, $"{null}"); + ClassicAssert.AreEqual(string.Empty, $"{null}"); } [Test] diff --git a/tests/Hydrogen.Tests/Misc/RandomTests.cs b/tests/Hydrogen.Tests/Misc/RandomTests.cs index 9a1ec6bfa..19d8f7509 100644 --- a/tests/Hydrogen.Tests/Misc/RandomTests.cs +++ b/tests/Hydrogen.Tests/Misc/RandomTests.cs @@ -9,6 +9,7 @@ using System; using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -28,20 +29,20 @@ public void Range_0() { public void Range_1() { var rng = new Random(31337); var range = rng.NextRange(1, rangeLength: 1); - Assert.AreEqual(0, range.Start); - Assert.AreEqual(0, range.End); + ClassicAssert.AreEqual(0, range.Start); + ClassicAssert.AreEqual(0, range.End); } [Test] public void Range_2() { var rng = new Random(31337); var range = rng.NextRange(2, true, rangeLength: 2); - Assert.AreEqual(0, range.Start); - Assert.AreEqual(1, range.End); + ClassicAssert.AreEqual(0, range.Start); + ClassicAssert.AreEqual(1, range.End); range = rng.NextRange(2, false, rangeLength: 2); - Assert.AreEqual(0, range.Start); - Assert.AreEqual(1, range.End); + ClassicAssert.AreEqual(0, range.Start); + ClassicAssert.AreEqual(1, range.End); } @@ -49,8 +50,8 @@ public void Range_2() { public void Range_Empty() { var rng = new Random(31337); var range = rng.NextRange(1, rangeLength: 0); - Assert.AreEqual(0, range.Start); - Assert.AreEqual(0, range.End); + ClassicAssert.AreEqual(0, range.Start); + ClassicAssert.AreEqual(0, range.End); } //[Test] diff --git a/tests/Hydrogen.Tests/Misc/RecursiveDataTypeTests.cs b/tests/Hydrogen.Tests/Misc/RecursiveDataTypeTests.cs index 2c2e0fc6b..ae368ba3a 100644 --- a/tests/Hydrogen.Tests/Misc/RecursiveDataTypeTests.cs +++ b/tests/Hydrogen.Tests/Misc/RecursiveDataTypeTests.cs @@ -9,6 +9,7 @@ using System; using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -45,7 +46,7 @@ public void TestFlattenIterator() { rdt.AddSubStates("B", "C", "D"); rdt.SubStates[1].AddSubStates("C1"); - CollectionAssert.AreEqual(new[] { "A", "B", "C", "C1", "D" }, rdt.Flatten()); + ClassicAssert.AreEqual(new[] { "A", "B", "C", "C1", "D" }, rdt.Flatten()); } [Test] @@ -55,8 +56,8 @@ public void TestFlattenArray() { rdt.AddSubStates("B", "C", "D"); rdt.SubStates[1].AddSubStates("C1"); rdt.Flatten(out var states, out var counts); - CollectionAssert.AreEqual(new[] { "A", "B", "C", "C1", "D" }, states); - CollectionAssert.AreEqual(new[] { 3, 0, 1, 0, 0 }, counts); + ClassicAssert.AreEqual(new[] { "A", "B", "C", "C1", "D" }, states); + ClassicAssert.AreEqual(new[] { 3, 0, 1, 0, 0 }, counts); } [Test] diff --git a/tests/Hydrogen.Tests/Misc/ResultTests.cs b/tests/Hydrogen.Tests/Misc/ResultTests.cs index bfe70f52a..97d11f5a9 100644 --- a/tests/Hydrogen.Tests/Misc/ResultTests.cs +++ b/tests/Hydrogen.Tests/Misc/ResultTests.cs @@ -7,6 +7,7 @@ // This notice must not be removed when duplicating this file or its contents, in whole or in part. using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -17,14 +18,14 @@ public class ResultTests { [Test] public void ValueTypeCast_Bool() { - Assert.IsTrue((bool)Result.From(true)); - Assert.IsFalse((bool)Result.From(false)); + ClassicAssert.IsTrue((bool)Result.From(true)); + ClassicAssert.IsFalse((bool)Result.From(false)); } [Test] public void ValueTypeCast_Result_Bool() { - Assert.AreEqual(Result.From(true), (Result)true); - Assert.AreEqual(Result.From(false), (Result)false); + ClassicAssert.AreEqual(Result.From(true), (Result)true); + ClassicAssert.AreEqual(Result.From(false), (Result)false); } [Test] diff --git a/tests/Hydrogen.Tests/Scopes/ContextScopeTest.cs b/tests/Hydrogen.Tests/Scopes/ContextScopeTest.cs index 67d26147d..b360f5ccb 100644 --- a/tests/Hydrogen.Tests/Scopes/ContextScopeTest.cs +++ b/tests/Hydrogen.Tests/Scopes/ContextScopeTest.cs @@ -10,6 +10,7 @@ using System.Linq; using System.Threading.Tasks; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -19,52 +20,52 @@ public class ContextScopeTest { [Test] public void TestNested_None_None() { - Assert.False(ExceptionOccured(ContextScopePolicy.None, ContextScopePolicy.None)); + ClassicAssert.IsFalse(ExceptionOccured(ContextScopePolicy.None, ContextScopePolicy.None)); } [Test] public void TestNested_None_MustBeNested() { - Assert.False(ExceptionOccured(ContextScopePolicy.None, ContextScopePolicy.MustBeNested)); + ClassicAssert.IsFalse(ExceptionOccured(ContextScopePolicy.None, ContextScopePolicy.MustBeNested)); } [Test] public void TestNested_None_MustBeRoot() { - Assert.True(ExceptionOccured(ContextScopePolicy.None, ContextScopePolicy.MustBeRoot)); + ClassicAssert.IsTrue(ExceptionOccured(ContextScopePolicy.None, ContextScopePolicy.MustBeRoot)); } [Test] public void TestNested_MustBeNested_None() { - Assert.True(ExceptionOccured(ContextScopePolicy.MustBeNested, ContextScopePolicy.None)); + ClassicAssert.IsTrue(ExceptionOccured(ContextScopePolicy.MustBeNested, ContextScopePolicy.None)); } [Test] public void TestNested_MustBeNested_MustBeNested() { - Assert.True(ExceptionOccured(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeNested)); + ClassicAssert.IsTrue(ExceptionOccured(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeNested)); } [Test] public void TestNested_MustBeNested_MustBeRoot() { - Assert.True(ExceptionOccured(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeRoot)); + ClassicAssert.IsTrue(ExceptionOccured(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeRoot)); } [Test] public void TestNested_MustBeRoot_None() { - Assert.False(ExceptionOccured(ContextScopePolicy.MustBeRoot, ContextScopePolicy.None)); + ClassicAssert.IsFalse(ExceptionOccured(ContextScopePolicy.MustBeRoot, ContextScopePolicy.None)); } [Test] public void TestNested_MustBeRoot_MustBeNested() { - Assert.False(ExceptionOccured(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested)); + ClassicAssert.IsFalse(ExceptionOccured(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested)); } [Test] public void TestNested_MustBeRoot_MustBeRoot() { - Assert.True(ExceptionOccured(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeRoot)); + ClassicAssert.IsTrue(ExceptionOccured(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeRoot)); } [Test] public void MultiThreaded_0() { - Assert.IsTrue(Enumerable.Range(1, 10).All(x => !ExceptionOccured(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested, Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100)))); + ClassicAssert.IsTrue(Enumerable.Range(1, 10).All(x => !ExceptionOccured(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested, Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100)))); } [Test] @@ -74,8 +75,8 @@ public void MultiThreaded_1() { task1.Start(); task2.Start(); Task.WaitAll(task1, task2); - Assert.IsTrue(task1.Result); - Assert.IsTrue(task2.Result); + ClassicAssert.IsTrue(task1.Result); + ClassicAssert.IsTrue(task2.Result); } [Test] @@ -85,110 +86,110 @@ public void MultiThreaded_2() { task1.Start(); task2.Start(); Task.WaitAll(task1, task2); - Assert.IsTrue(task1.Result); - Assert.IsTrue(task2.Result); + ClassicAssert.IsTrue(task1.Result); + ClassicAssert.IsTrue(task2.Result); } [Test] public void TestNested_None_None_Async() { - Assert.False(ExceptionOccuredAsync(ContextScopePolicy.None, ContextScopePolicy.None)); + ClassicAssert.IsFalse(ExceptionOccuredAsync(ContextScopePolicy.None, ContextScopePolicy.None)); } [Test] public async Task TestNested_None_None_Async2() { - Assert.False(await ExceptionOccuredAsync2(ContextScopePolicy.None, ContextScopePolicy.None)); + ClassicAssert.IsFalse(await ExceptionOccuredAsync2(ContextScopePolicy.None, ContextScopePolicy.None)); } [Test] public void TestNested_None_MustBeNested_Async() { - Assert.False(ExceptionOccuredAsync(ContextScopePolicy.None, ContextScopePolicy.MustBeNested)); + ClassicAssert.IsFalse(ExceptionOccuredAsync(ContextScopePolicy.None, ContextScopePolicy.MustBeNested)); } [Test] public async Task TestNested_None_MustBeNested_Async2() { - Assert.False(await ExceptionOccuredAsync2(ContextScopePolicy.None, ContextScopePolicy.MustBeNested)); + ClassicAssert.IsFalse(await ExceptionOccuredAsync2(ContextScopePolicy.None, ContextScopePolicy.MustBeNested)); } [Test] public void TestNested_None_MustBeRoot_Async() { - Assert.True(ExceptionOccuredAsync(ContextScopePolicy.None, ContextScopePolicy.MustBeRoot)); + ClassicAssert.IsTrue(ExceptionOccuredAsync(ContextScopePolicy.None, ContextScopePolicy.MustBeRoot)); } [Test] public async Task TestNested_None_MustBeRoot_Async2() { - Assert.True(await ExceptionOccuredAsync2(ContextScopePolicy.None, ContextScopePolicy.MustBeRoot)); + ClassicAssert.IsTrue(await ExceptionOccuredAsync2(ContextScopePolicy.None, ContextScopePolicy.MustBeRoot)); } [Test] public void TestNested_MustBeNested_None_Async() { - Assert.True(ExceptionOccuredAsync(ContextScopePolicy.MustBeNested, ContextScopePolicy.None)); + ClassicAssert.IsTrue(ExceptionOccuredAsync(ContextScopePolicy.MustBeNested, ContextScopePolicy.None)); } [Test] public async Task TestNested_MustBeNested_None_Async2() { - Assert.True(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeNested, ContextScopePolicy.None)); + ClassicAssert.IsTrue(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeNested, ContextScopePolicy.None)); } [Test] public void TestNested_MustBeNested_MustBeNested_Async() { - Assert.True(ExceptionOccuredAsync(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeNested)); + ClassicAssert.IsTrue(ExceptionOccuredAsync(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeNested)); } [Test] public async Task TestNested_MustBeNested_MustBeNested_Async2() { - Assert.True(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeNested)); + ClassicAssert.IsTrue(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeNested)); } [Test] public void TestNested_MustBeNested_MustBeRoot_Async() { - Assert.True(ExceptionOccuredAsync(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeRoot)); + ClassicAssert.IsTrue(ExceptionOccuredAsync(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeRoot)); } [Test] public async Task TestNested_MustBeNested_MustBeRoot_Async2() { - Assert.True(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeRoot)); + ClassicAssert.IsTrue(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeNested, ContextScopePolicy.MustBeRoot)); } [Test] public void TestNested_MustBeRoot_None_Async() { - Assert.False(ExceptionOccuredAsync(ContextScopePolicy.MustBeRoot, ContextScopePolicy.None)); + ClassicAssert.IsFalse(ExceptionOccuredAsync(ContextScopePolicy.MustBeRoot, ContextScopePolicy.None)); } [Test] public async Task TestNested_MustBeRoot_None_Async2() { - Assert.False(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeRoot, ContextScopePolicy.None)); + ClassicAssert.IsFalse(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeRoot, ContextScopePolicy.None)); } [Test] public void TestNested_MustBeRoot_MustBeNested_Async() { - Assert.False(ExceptionOccuredAsync(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested)); + ClassicAssert.IsFalse(ExceptionOccuredAsync(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested)); } [Test] public async Task TestNested_MustBeRoot_MustBeNested_Async2() { - Assert.False(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested)); + ClassicAssert.IsFalse(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested)); } [Test] public void TestNested_MustBeRoot_MustBeRoot_Async() { - Assert.True(ExceptionOccuredAsync(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeRoot)); + ClassicAssert.IsTrue(ExceptionOccuredAsync(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeRoot)); } [Test] public async Task TestNested_MustBeRoot_MustBeRoot_Async2() { - Assert.True(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeRoot)); + ClassicAssert.IsTrue(await ExceptionOccuredAsync2(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeRoot)); } [Test] public void MultiThreaded_0_Async() { - Assert.IsTrue(Enumerable.Range(1, 10).All(x => !ExceptionOccuredAsync(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested, Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100)))); + ClassicAssert.IsTrue(Enumerable.Range(1, 10).All(x => !ExceptionOccuredAsync(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested, Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100)))); } //[Test] //public async Task MultiThreaded_0_Async2() { - // Assert.IsTrue(AsyncEnumerable.Range(1, 10).AllAsync(async x => await !ExceptionOccuredAsync2(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested, Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100)) + // ClassicAssert.IsTrue(AsyncEnumerable.Range(1, 10).AllAsync(async x => await !ExceptionOccuredAsync2(ContextScopePolicy.MustBeRoot, ContextScopePolicy.MustBeNested, Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100), Tools.Maths.RNG.Next(0, 100)) // )); //} @@ -202,8 +203,8 @@ public void MultiThreaded_1_Async() { task1.Start(); task2.Start(); Task.WaitAll(task1, task2); - Assert.IsTrue(task1.Result); - Assert.IsTrue(task2.Result); + ClassicAssert.IsTrue(task1.Result); + ClassicAssert.IsTrue(task2.Result); } [Test] @@ -213,8 +214,8 @@ public void MultiThreaded_2_Async() { task1.Start(); task2.Start(); Task.WaitAll(task1, task2); - Assert.IsTrue(task1.Result); - Assert.IsTrue(task2.Result); + ClassicAssert.IsTrue(task1.Result); + ClassicAssert.IsTrue(task2.Result); } diff --git a/tests/Hydrogen.Tests/Serialization/AutoSizedSerializerTest.cs b/tests/Hydrogen.Tests/Serialization/AutoSizedSerializerTest.cs index a9f0bc1b7..4f3fad54c 100644 --- a/tests/Hydrogen.Tests/Serialization/AutoSizedSerializerTest.cs +++ b/tests/Hydrogen.Tests/Serialization/AutoSizedSerializerTest.cs @@ -9,7 +9,6 @@ using System; using System.Text; using NUnit.Framework; -using Org.BouncyCastle.Utilities; namespace Hydrogen.Tests; diff --git a/tests/Hydrogen.Tests/Serialization/DefaultSerializerTests.cs b/tests/Hydrogen.Tests/Serialization/DefaultSerializerTests.cs index 350787f58..034b73a22 100644 --- a/tests/Hydrogen.Tests/Serialization/DefaultSerializerTests.cs +++ b/tests/Hydrogen.Tests/Serialization/DefaultSerializerTests.cs @@ -14,6 +14,7 @@ using AutoFixture; using FluentAssertions; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -38,7 +39,7 @@ public void ValueTypeSerializeDeserialize() { var writer = new EndianBinaryWriter(EndianBitConverter.Little, memoryStream); var byteCount = serializer.SerializeReturnSize(item, writer); - Assert.AreEqual(memoryStream.Length, byteCount); + ClassicAssert.AreEqual(memoryStream.Length, byteCount); memoryStream.Seek(0, SeekOrigin.Begin); var reader = new EndianBinaryReader(EndianBitConverter.Little, memoryStream); @@ -56,7 +57,7 @@ public void CollectionSerializeDeserialize() { var byteCount = serializer.SerializeReturnSize(item, writer); var hash = Hashers.Hash(CHF.SHA2_256, memoryStream.ToArray()); - Assert.AreEqual(memoryStream.Length, byteCount); + ClassicAssert.AreEqual(memoryStream.Length, byteCount); memoryStream.Seek(0, SeekOrigin.Begin); var reader = new EndianBinaryReader(EndianBitConverter.Little, memoryStream); @@ -78,7 +79,7 @@ public void NullObjectSerializeDeserialize() { var writer = new EndianBinaryWriter(EndianBitConverter.Little, memoryStream); var byteCount = serializer.SerializeReturnSize(item, writer); - Assert.AreEqual(memoryStream.Length, byteCount); + ClassicAssert.AreEqual(memoryStream.Length, byteCount); memoryStream.Seek(0, SeekOrigin.Begin); var reader = new EndianBinaryReader(EndianBitConverter.Little, memoryStream); @@ -97,7 +98,7 @@ public void ReferenceTypeSerializeDeserialize() { var writer = new EndianBinaryWriter(EndianBitConverter.Little, memoryStream); var byteCount = serializer.SerializeReturnSize(item, writer); - Assert.AreEqual(memoryStream.Length, byteCount); + ClassicAssert.AreEqual(memoryStream.Length, byteCount); memoryStream.Seek(0, SeekOrigin.Begin); var reader = new EndianBinaryReader(EndianBitConverter.Little, memoryStream); @@ -116,7 +117,7 @@ public void GenericReferenceTypeSerializeDeserialize() { var writer = new EndianBinaryWriter(EndianBitConverter.Little, memoryStream); var byteCount = serializer.SerializeReturnSize(item, writer); - Assert.AreEqual(memoryStream.Length, byteCount); + ClassicAssert.AreEqual(memoryStream.Length, byteCount); memoryStream.Seek(0, SeekOrigin.Begin); var reader = new EndianBinaryReader(EndianBitConverter.Little, memoryStream); @@ -143,7 +144,7 @@ public void CircularReferenceObj() { var writer = new EndianBinaryWriter(EndianBitConverter.Little, memoryStream); var byteCount = serializer.SerializeReturnSize(parent, writer); - Assert.AreEqual(memoryStream.Length, byteCount); + ClassicAssert.AreEqual(memoryStream.Length, byteCount); memoryStream.Seek(0, SeekOrigin.Begin); var reader = new EndianBinaryReader(EndianBitConverter.Little, memoryStream); @@ -175,7 +176,7 @@ public void ObjectTypePropertiesSerialized() { var writer = new EndianBinaryWriter(EndianBitConverter.Little, memoryStream); var byteCount = serializer.SerializeReturnSize(item, writer); - Assert.AreEqual(memoryStream.Length, byteCount); + ClassicAssert.AreEqual(memoryStream.Length, byteCount); memoryStream.Seek(0, SeekOrigin.Begin); var reader = new EndianBinaryReader(EndianBitConverter.Little, memoryStream); @@ -232,7 +233,7 @@ public void CalculateSizeOfObject() { var serializer = ItemSerializer.Default; var calculatedSize = serializer.CalculateSize(item); var serialized = serializer.SerializeBytesLE(item); - Assert.AreEqual(calculatedSize, serialized.Length); + ClassicAssert.AreEqual(calculatedSize, serialized.Length); } [Test] @@ -244,7 +245,7 @@ public void CalculateSizeOfObject_Bug() { var serializer = ItemSerializer.Default; var calculatedSize = serializer.CalculateSize(item); var serialized = serializer.SerializeBytesLE(item); - Assert.AreEqual(calculatedSize, serialized.Length); + ClassicAssert.AreEqual(calculatedSize, serialized.Length); } [Test] @@ -255,17 +256,17 @@ public void CalculateTotalSize() { var writer = new EndianBinaryWriter(EndianBitConverter.Little, memoryStream); var calculatedTotalSize = serializer.CalculateTotalSize(items, true, out var sizes); - Assert.AreEqual(0, memoryStream.Length); + ClassicAssert.AreEqual(0, memoryStream.Length); var serializedTotal = 0L; foreach (var item in items) { serializedTotal += serializer.SerializeReturnSize(item, writer); } - Assert.AreEqual(serializedTotal, calculatedTotalSize); - Assert.AreEqual(memoryStream.Length, calculatedTotalSize); - Assert.AreEqual(items.Count(), sizes.Length); - Assert.AreEqual(calculatedTotalSize, sizes.Sum(x => x)); + ClassicAssert.AreEqual(serializedTotal, calculatedTotalSize); + ClassicAssert.AreEqual(memoryStream.Length, calculatedTotalSize); + ClassicAssert.AreEqual(items.Count(), sizes.Length); + ClassicAssert.AreEqual(calculatedTotalSize, sizes.Sum(x => x)); } [Test] @@ -276,11 +277,11 @@ public void EnumSerializeDeserialize() { using var memoryStream = new MemoryStream(); var writer = new EndianBinaryWriter(EndianBitConverter.Little, memoryStream); var size = serializer.CalculateSize(item); - Assert.AreEqual(0, memoryStream.Length); + ClassicAssert.AreEqual(0, memoryStream.Length); IItemSerializer deserializer = ItemSerializer.Default; var serializedSize = deserializer.SerializeReturnSize(item, writer); - Assert.AreEqual(serializedSize, size); + ClassicAssert.AreEqual(serializedSize, size); } } diff --git a/tests/Hydrogen.Tests/Serialization/PaddedSerializerTests.cs b/tests/Hydrogen.Tests/Serialization/PaddedSerializerTests.cs index 507cca766..6ad37d0ac 100644 --- a/tests/Hydrogen.Tests/Serialization/PaddedSerializerTests.cs +++ b/tests/Hydrogen.Tests/Serialization/PaddedSerializerTests.cs @@ -8,6 +8,7 @@ using System.Text; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -21,7 +22,7 @@ public void TestPaddedSerializer_Empty([Values] SizeDescriptorStrategy sizeDescr var size = serializer.CalculateSize(@value); var bytes = serializer.SerializeBytesLE(@value); Assert.That(bytes.Length, Is.EqualTo(size)); - Assert.AreEqual(100, bytes.Length); + ClassicAssert.AreEqual(100, bytes.Length); } } diff --git a/tests/Hydrogen.Tests/Serialization/PolymorphicSerializerTests.cs b/tests/Hydrogen.Tests/Serialization/PolymorphicSerializerTests.cs new file mode 100644 index 000000000..fb0323e50 --- /dev/null +++ b/tests/Hydrogen.Tests/Serialization/PolymorphicSerializerTests.cs @@ -0,0 +1,83 @@ +// Copyright (c) Sphere 10 Software. All rights reserved. (https://sphere10.com) +// Author: Herman Schoenfeld +// +// Distributed under the MIT software license, see the accompanying file +// LICENSE or visit http://www.opensource.org/licenses/mit-license.php. +// +// This notice must not be removed when duplicating this file or its contents, in whole or in part. + +using System; +using System.Collections; +using System.Collections.Generic; +using FluentAssertions; +using NUnit.Framework; + +namespace Hydrogen.Tests; + +[TestFixture] +[Parallelizable] +public class PolymorphicSerializerTests { + + [KnownSubType] + [KnownSubType] + public abstract class Animal { + public string Name { get; set; } + + public object Tag { get; set; } + } + + public sealed class Dog : Animal { + public string Breed { get; set; } + } + + public sealed class Cat : Animal { + public string Color { get; set; } + } + + public sealed class Zoo { + + public List Animals { get; set; } = new(); + + public object[] Objects { get; set; } + + } + + + [Test] + public void PolymorphicCase() { + var zoo = new Zoo(); + + var dog1 = new Dog { Name = "Rex", Breed = "German Shepherd" }; + dog1.Tag = null; + + var dog2 = new Dog { Name = "Fido", Breed = "Poodle" }; + dog2.Tag = dog1; + + var dog3 = new Dog { Name = "Spot", Breed = "Dalmatian" }; + dog3.Tag = dog3; + + + var cat1 = new Cat { Name = "Whiskers", Color = "White" }; + cat1.Tag = zoo; + + var cat2 = new Cat { Name = "Mittens", Color = "Black" }; + cat2.Tag = null; + + zoo.Animals.AddRange([ dog1, dog2, dog3, cat1, cat2 ]); + + zoo.Objects = ["alpha", null, 1L, 1M, dog1, zoo ]; + + + var serializer = ItemSerializer.Default; + + var size = serializer.CalculateSize(zoo); + var bytes = serializer.SerializeBytesLE(zoo); + var deserializedZoo = serializer.DeserializeBytesLE(bytes); + + Assert.That(bytes.Length, Is.EqualTo(size)); + + deserializedZoo.Should().BeEquivalentTo(zoo, x=> x.IgnoringCyclicReferences()); + + } + +} diff --git a/tests/Hydrogen.Tests/Serialization/SerializerFactoryTests.cs b/tests/Hydrogen.Tests/Serialization/SerializerFactoryTests.cs index 84d84bcfa..669ea013a 100644 --- a/tests/Hydrogen.Tests/Serialization/SerializerFactoryTests.cs +++ b/tests/Hydrogen.Tests/Serialization/SerializerFactoryTests.cs @@ -10,6 +10,7 @@ using System.Collections.Generic; using System.Linq; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -77,7 +78,7 @@ public void GetSerializerHierarchy_Open() { var factory = new SerializerFactory(); factory.Register(typeof(IList<>), typeof(ListInterfaceSerializer<>)); // 0 factory.Register(PrimitiveSerializer.Instance); // 1 - CollectionAssert.AreEqual(factory.GetSerializerHierarchy(typeof(IList)).Flatten(), new[] { SerializerFactory.PermanentTypeCodeStartDefault + 0, SerializerFactory.PermanentTypeCodeStartDefault + 1 }); + ClassicAssert.AreEqual(factory.GetSerializerHierarchy(typeof(IList)).Flatten(), new[] { SerializerFactory.PermanentTypeCodeStartDefault + 0, SerializerFactory.PermanentTypeCodeStartDefault + 1 }); } [Test] @@ -95,7 +96,7 @@ public void GetSerializerHierarchy_Open_Complex() { // float, 1 // IList< 2 // int>>>> 0 - CollectionAssert.AreEqual(factory.GetSerializerHierarchy(typeof(IList, KeyValuePair>>>)).Flatten(), new[] { 2, 3, 2, 0, 3, 1, 2, 0 }.Select(x => SerializerFactory.PermanentTypeCodeStartDefault + x)); + ClassicAssert.AreEqual(factory.GetSerializerHierarchy(typeof(IList, KeyValuePair>>>)).Flatten(), new[] { 2, 3, 2, 0, 3, 1, 2, 0 }.Select(x => SerializerFactory.PermanentTypeCodeStartDefault + x)); } @@ -118,7 +119,7 @@ public void GetSerializerHierarchy_Closed_Complex() { ); factory.Register(instance); // 4 (closed specific instance) - CollectionAssert.AreEqual(factory.GetSerializerHierarchy(typeof(IList, KeyValuePair>>>)).Flatten(), new[] { SerializerFactory.PermanentTypeCodeStartDefault + 4 }); + ClassicAssert.AreEqual(factory.GetSerializerHierarchy(typeof(IList, KeyValuePair>>>)).Flatten(), new[] { SerializerFactory.PermanentTypeCodeStartDefault + 4 }); } @@ -171,7 +172,7 @@ public void FromSerializerHierarchy_Closed_Complex() { ); factory.Register(instance); // 4 (closed specific instance) - CollectionAssert.AreEqual(factory.GetSerializerHierarchy(typeof(IList, KeyValuePair>>>)).Flatten(), new[] { SerializerFactory.PermanentTypeCodeStartDefault + 4 }); + ClassicAssert.AreEqual(factory.GetSerializerHierarchy(typeof(IList, KeyValuePair>>>)).Flatten(), new[] { SerializerFactory.PermanentTypeCodeStartDefault + 4 }); } diff --git a/tests/Hydrogen.Tests/Streams/ExtendedMemoryStreamTests.cs b/tests/Hydrogen.Tests/Streams/ExtendedMemoryStreamTests.cs index 473b1eab2..e0499871e 100644 --- a/tests/Hydrogen.Tests/Streams/ExtendedMemoryStreamTests.cs +++ b/tests/Hydrogen.Tests/Streams/ExtendedMemoryStreamTests.cs @@ -10,6 +10,7 @@ using System.IO; using NUnit.Framework; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -21,9 +22,9 @@ public class ExtendedMemoryStreamTests { public void Empty([Values] InnerListType listType) { using (CreateTestStream(listType, 10, out var stream)) { var expected = new MemoryStream(); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); } } @@ -34,10 +35,10 @@ public void ReadAll([Values] InnerListType listType) { var data = new Random(31337).NextBytes(100); stream.WriteBytes(data); expected.WriteBytes(data); - Assert.AreEqual(expected.ReadBytes(100), stream.ReadBytes(100)); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.ReadBytes(100), stream.ReadBytes(100)); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); } } @@ -50,9 +51,9 @@ public void RemoveAll([Values] InnerListType listType) { expected.WriteBytes(data); stream.SetLength(0); expected.SetLength(0); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); } } @@ -62,7 +63,7 @@ public void SeekEnd_Empty([Values] InnerListType listType) { var expected = new MemoryStream(); stream.Seek(0, SeekOrigin.End); expected.Seek(0, SeekOrigin.End); - Assert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Position, stream.Position); } } @@ -75,7 +76,7 @@ public void SeekEnd_NotEmpty([Values] InnerListType listType) { expected.WriteBytes(data); stream.Seek(0, SeekOrigin.End); expected.Seek(0, SeekOrigin.End); - Assert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Position, stream.Position); } } diff --git a/tests/Hydrogen.Tests/Streams/FragmentedStreamTests.cs b/tests/Hydrogen.Tests/Streams/FragmentedStreamTests.cs index b8bb0f58d..e38347924 100644 --- a/tests/Hydrogen.Tests/Streams/FragmentedStreamTests.cs +++ b/tests/Hydrogen.Tests/Streams/FragmentedStreamTests.cs @@ -10,6 +10,7 @@ using System.IO; using NUnit.Framework; using Hydrogen.NUnit; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -35,9 +36,9 @@ public void Empty() { var stream = new FragmentedStream(fragments); var expected = new MemoryStream(); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); } [Test] @@ -48,7 +49,7 @@ public void WriteEmpty() { var data = Array.Empty(); expected.WriteBytes(data); stream.WriteBytes(data); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); } [Test] @@ -60,7 +61,7 @@ public void Write([Range(1, 100)] int iteration) { var data = rng.NextBytes(rng.Next(0, 100)); expected.WriteBytes(data); stream.WriteBytes(data); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); } [Test] @@ -76,10 +77,10 @@ public void ReadAll() { stream.Seek(0, SeekOrigin.Begin); expected.Seek(0, SeekOrigin.Begin); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.ReadBytes(data.Length), stream.ReadBytes(data.Length)); + ClassicAssert.AreEqual(expected.ReadBytes(data.Length), stream.ReadBytes(data.Length)); } [Test] @@ -92,23 +93,23 @@ public void WriteUpdateAndAdd() { stream.WriteBytes(data); expected.WriteBytes(data); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); int halfway = data.Length / 2; byte[] newData = Random.NextBytes(data.Length); stream.Seek(halfway, SeekOrigin.Begin); expected.Seek(halfway, SeekOrigin.Begin); - Assert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Position, stream.Position); stream.WriteBytes(newData); expected.WriteBytes(newData); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); } [Test] @@ -129,8 +130,8 @@ public void SeekAndRead(SeekOrigin origin, int offset) { stream.Seek(offset, origin); expected.Seek(offset, origin); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.ReadBytes(1), stream.ReadBytes(1)); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.ReadBytes(1), stream.ReadBytes(1)); } [Test] @@ -146,9 +147,9 @@ public void RemoveAll() { stream.SetLength(0); expected.SetLength(0); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); } [Test] @@ -165,9 +166,9 @@ public void IncreaseSize() { stream.SetLength(stream.Length + newSpace); expected.SetLength(expected.Length + newSpace); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); } [Test] @@ -182,17 +183,17 @@ public void DecreaseSize([Range(1, 1000)] int iteration) { expected.WriteBytes(data); - Assert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.Position, stream.Position); int newSpace = Random.Next(0, (int)expected.Length); expected.SetLength(expected.Length - newSpace); stream.SetLength(stream.Length - newSpace); - Assert.AreEqual(expected.Position, stream.Position); - Assert.AreEqual(expected.Length, stream.Length); - Assert.AreEqual(expected.ToArray(), stream.ToArray()); + ClassicAssert.AreEqual(expected.Position, stream.Position); + ClassicAssert.AreEqual(expected.Length, stream.Length); + ClassicAssert.AreEqual(expected.ToArray(), stream.ToArray()); } [Test] diff --git a/tests/Hydrogen.Tests/Text/ParserTests.cs b/tests/Hydrogen.Tests/Text/ParserTests.cs index 959b8e948..0ffdc4d39 100644 --- a/tests/Hydrogen.Tests/Text/ParserTests.cs +++ b/tests/Hydrogen.Tests/Text/ParserTests.cs @@ -9,6 +9,7 @@ using NUnit.Framework; using System; using System.Net; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -17,13 +18,13 @@ public class ParserTests { [Test] public void Parse() { - Assert.AreEqual(1, Tools.Parser.Parse("1")); - Assert.AreEqual(1, Tools.Parser.Parse("1")); - Assert.AreEqual(1, Tools.Parser.Parse("1")); - Assert.AreEqual(1.0, Tools.Parser.Parse("1")); + ClassicAssert.AreEqual(1, Tools.Parser.Parse("1")); + ClassicAssert.AreEqual(1, Tools.Parser.Parse("1")); + ClassicAssert.AreEqual(1, Tools.Parser.Parse("1")); + ClassicAssert.AreEqual(1.0, Tools.Parser.Parse("1")); var guid = Guid.NewGuid(); - Assert.AreEqual(guid, Tools.Parser.Parse(guid.ToString())); - Assert.AreEqual(guid, Tools.Parser.Parse(guid.ToStrictAlphaString())); + ClassicAssert.AreEqual(guid, Tools.Parser.Parse(guid.ToString())); + ClassicAssert.AreEqual(guid, Tools.Parser.Parse(guid.ToStrictAlphaString())); } [Test] @@ -34,21 +35,21 @@ public void Throws() { [Test] public void Nullable() { - Assert.IsNull(Tools.Parser.Parse("")); - Assert.IsNull(Tools.Parser.Parse(null)); + ClassicAssert.IsNull(Tools.Parser.Parse("")); + ClassicAssert.IsNull(Tools.Parser.Parse(null)); } [Test] public void SafeParse() { - //Assert.IsNull(Tools.Parser.SafeParseInt32("bad")); - Assert.IsNull(Tools.Parser.SafeParse("bad")); - Assert.AreEqual(default(int), Tools.Parser.SafeParse("bad")); + //ClassicAssert.IsNull(Tools.Parser.SafeParseInt32("bad")); + ClassicAssert.IsNull(Tools.Parser.SafeParse("bad")); + ClassicAssert.AreEqual(default(int), Tools.Parser.SafeParse("bad")); } [Test] public void IPAddr() { - Assert.AreEqual(IPAddress.Parse("127.0.0.1"), Tools.Parser.Parse("127.0.0.1")); + ClassicAssert.AreEqual(IPAddress.Parse("127.0.0.1"), Tools.Parser.Parse("127.0.0.1")); Assert.Throws(() => Tools.Parser.Parse("asdfhaskdfj")); } } diff --git a/tests/Hydrogen.Tests/Text/StringFormatterTests.cs b/tests/Hydrogen.Tests/Text/StringFormatterTests.cs index 9c02b35bb..aee996eff 100644 --- a/tests/Hydrogen.Tests/Text/StringFormatterTests.cs +++ b/tests/Hydrogen.Tests/Text/StringFormatterTests.cs @@ -9,6 +9,7 @@ using System; using System.Collections.Generic; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -18,33 +19,33 @@ public class StringFormatterTests { [Test] public void SimpleTest_1() { - Assert.AreEqual(string.Format("{0}", 1), Tools.Text.FormatEx("{0}", 1)); + ClassicAssert.AreEqual(string.Format("{0}", 1), Tools.Text.FormatEx("{0}", 1)); } [Test] public void SimpleTest_2() { - Assert.AreEqual(string.Format(" {0}", 23), Tools.Text.FormatEx(" {0}", 23)); + ClassicAssert.AreEqual(string.Format(" {0}", 23), Tools.Text.FormatEx(" {0}", 23)); } public void SimpleTest_3() { - Assert.AreEqual(string.Format(" {0}", 23), Tools.Text.FormatEx(" {0}", 23)); + ClassicAssert.AreEqual(string.Format(" {0}", 23), Tools.Text.FormatEx(" {0}", 23)); } [Test] public void SimpleTest_4() { - Assert.AreEqual(string.Format(" !{0}! ", 99), Tools.Text.FormatEx(" !{0}! ", 99)); + ClassicAssert.AreEqual(string.Format(" !{0}! ", 99), Tools.Text.FormatEx(" !{0}! ", 99)); } [Test] public void SimpleTest_5() { var now = DateTime.Now; - Assert.AreEqual(string.Format(" x{0:yyyy-MM-dd}x ", now), Tools.Text.FormatEx(" x{0:yyyy-MM-dd}x ", now)); + ClassicAssert.AreEqual(string.Format(" x{0:yyyy-MM-dd}x ", now), Tools.Text.FormatEx(" x{0:yyyy-MM-dd}x ", now)); } [Test] public void SimpleTest_6() { var now = DateTime.Now; - Assert.AreEqual(string.Format(" ${0:yyyy-MM-dd}^^^^^{1}{2:HH:mm:ss tt zz}! ", now, "ALPHA", now), Tools.Text.FormatEx(" ${0:yyyy-MM-dd}^^^^^{1}{2:HH:mm:ss tt zz}! ", now, "ALPHA", now)); + ClassicAssert.AreEqual(string.Format(" ${0:yyyy-MM-dd}^^^^^{1}{2:HH:mm:ss tt zz}! ", now, "ALPHA", now), Tools.Text.FormatEx(" ${0:yyyy-MM-dd}^^^^^{1}{2:HH:mm:ss tt zz}! ", now, "ALPHA", now)); } [Test] @@ -57,7 +58,7 @@ public void LookupTest_1() { return null; } }; - Assert.AreEqual("1", Tools.Text.FormatEx("{token}", resolver)); + ClassicAssert.AreEqual("1", Tools.Text.FormatEx("{token}", resolver)); } [Test] @@ -72,7 +73,7 @@ public void LookupTest_2() { return null; } }; - Assert.AreEqual(" X1lhjk34k2342kj4h2!", Tools.Text.FormatEx(" X{token1}lhjk34k2342kj4h{token2}!", resolver)); + ClassicAssert.AreEqual(" X1lhjk34k2342kj4h2!", Tools.Text.FormatEx(" X{token1}lhjk34k2342kj4h{token2}!", resolver)); } [Test] @@ -87,42 +88,42 @@ public void MixedTest_1() { return null; } }; - Assert.AreEqual(" !ABCDEEDCBA! ", Tools.Text.FormatEx(" !{0}{token1}{1}{token2}{2}{2}{token2}{1}{token1}{0}! ", resolver, "A", "C", "E")); + ClassicAssert.AreEqual(" !ABCDEEDCBA! ", Tools.Text.FormatEx(" !{0}{token1}{1}{token2}{2}{2}{token2}{1}{token1}{0}! ", resolver, "A", "C", "E")); } [Test] public void EscapedTest_1() { - Assert.AreEqual(string.Format("{{"), Tools.Text.FormatEx("{{")); + ClassicAssert.AreEqual(string.Format("{{"), Tools.Text.FormatEx("{{")); } [Test] public void EscapedTest_2() { - Assert.AreEqual(string.Format("{{"), Tools.Text.FormatEx("{{")); + ClassicAssert.AreEqual(string.Format("{{"), Tools.Text.FormatEx("{{")); } [Test] public void EscapedTest_3() { - Assert.AreEqual(string.Format("{{0}}"), Tools.Text.FormatEx("{{0}}")); + ClassicAssert.AreEqual(string.Format("{{0}}"), Tools.Text.FormatEx("{{0}}")); } [Test] public void EscapedTest_4() { - Assert.AreEqual(string.Format("{{{0}", 1), Tools.Text.FormatEx("{{{0}", 1)); + ClassicAssert.AreEqual(string.Format("{{{0}", 1), Tools.Text.FormatEx("{{{0}", 1)); } [Test] public void EscapedTest_5() { - Assert.AreEqual(string.Format("{0}}}", 1), Tools.Text.FormatEx("{0}}}", 1)); + ClassicAssert.AreEqual(string.Format("{0}}}", 1), Tools.Text.FormatEx("{0}}}", 1)); } [Test] public void EscapedTest_6() { - Assert.AreEqual(string.Format("{{{0}}}", 1), Tools.Text.FormatEx("{{{0}}}", 1)); + ClassicAssert.AreEqual(string.Format("{{{0}}}", 1), Tools.Text.FormatEx("{{{0}}}", 1)); } [Test] public void EscapedTest_7() { - Assert.AreEqual(string.Format("{{}}", 1), Tools.Text.FormatEx("{{}}", 1)); + ClassicAssert.AreEqual(string.Format("{{}}", 1), Tools.Text.FormatEx("{{}}", 1)); } @@ -138,7 +139,7 @@ public void EscapedTest_8() { return null; } }; - Assert.AreEqual(" {!A{BCD}EEDCBA!} ", Tools.Text.FormatEx(" {{!{0}{{{token1}{1}{token2}}}{2}{2}{token2}{1}{token1}{0}!}} ", resolver, "A", "C", "E")); + ClassicAssert.AreEqual(" {!A{BCD}EEDCBA!} ", Tools.Text.FormatEx(" {{!{0}{{{token1}{1}{token2}}}{2}{2}{token2}{1}{token1}{0}!}} ", resolver, "A", "C", "E")); } [Test] diff --git a/tests/Hydrogen.Tests/Text/StringTests.cs b/tests/Hydrogen.Tests/Text/StringTests.cs index d7e17b10c..dd806b617 100644 --- a/tests/Hydrogen.Tests/Text/StringTests.cs +++ b/tests/Hydrogen.Tests/Text/StringTests.cs @@ -7,6 +7,7 @@ // This notice must not be removed when duplicating this file or its contents, in whole or in part. using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -17,63 +18,63 @@ public class StringTests { [Test] public void TrimStart_1() { - Assert.AreEqual("", "alpha".TrimStart("alpha")); + ClassicAssert.AreEqual("", "alpha".TrimStart("alpha")); } [Test] public void TrimStart_2() { - Assert.AreEqual("1", "alpha1".TrimStart("alpha")); + ClassicAssert.AreEqual("1", "alpha1".TrimStart("alpha")); } [Test] public void TrimStart_3() { - Assert.AreEqual("1alpha2", "1alpha2".TrimStart("alpha")); + ClassicAssert.AreEqual("1alpha2", "1alpha2".TrimStart("alpha")); } [Test] public void TrimStart_4() { - Assert.AreEqual("", "aLphA".TrimStart("alpha", false)); + ClassicAssert.AreEqual("", "aLphA".TrimStart("alpha", false)); } [Test] public void TrimStart_5() { - Assert.AreEqual("1", "AlpHa1".TrimStart("alpha", false)); + ClassicAssert.AreEqual("1", "AlpHa1".TrimStart("alpha", false)); } [Test] public void TrimStart_6() { - Assert.AreEqual("1aLPha2", "1aLPha2".TrimStart("alpha", false)); + ClassicAssert.AreEqual("1aLPha2", "1aLPha2".TrimStart("alpha", false)); } [Test] public void TrimEnd_1() { - Assert.AreEqual("", "alpha".TrimEnd("alpha")); + ClassicAssert.AreEqual("", "alpha".TrimEnd("alpha")); } [Test] public void TrimEnd_2() { - Assert.AreEqual("1", "1alpha".TrimEnd("alpha")); + ClassicAssert.AreEqual("1", "1alpha".TrimEnd("alpha")); } [Test] public void TrimEnd_3() { - Assert.AreEqual("1aLpha2", "1aLpha2".TrimEnd("alpha")); + ClassicAssert.AreEqual("1aLpha2", "1aLpha2".TrimEnd("alpha")); } [Test] public void TrimEnd_4() { - Assert.AreEqual("", "alpHa".TrimEnd("alpha", false)); + ClassicAssert.AreEqual("", "alpHa".TrimEnd("alpha", false)); } [Test] public void TrimEnd_5() { - Assert.AreEqual("1", "1AlphA".TrimEnd("alpha", false)); + ClassicAssert.AreEqual("1", "1AlphA".TrimEnd("alpha", false)); } [Test] public void TrimEnd_6() { - Assert.AreEqual("1alpHa2", "1alpHa2".TrimEnd("alpha", false)); + ClassicAssert.AreEqual("1alpHa2", "1alpHa2".TrimEnd("alpha", false)); } } diff --git a/tests/Hydrogen.Tests/Text/UrlIDTests.cs b/tests/Hydrogen.Tests/Text/UrlIDTests.cs index b81ecdc29..c4d785b37 100644 --- a/tests/Hydrogen.Tests/Text/UrlIDTests.cs +++ b/tests/Hydrogen.Tests/Text/UrlIDTests.cs @@ -9,6 +9,7 @@ using System.Collections.Generic; using System.Threading.Tasks; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -35,7 +36,7 @@ public async Task PermiateAll() { var checkTask = new Task(() => { while (!queue.HasFinishedProducing) { var toCheck = queue.Take(); - Assert.AreEqual(false, permutes.Contains(toCheck), "Value {0} clashed".FormatWith(toCheck)); + ClassicAssert.AreEqual(false, permutes.Contains(toCheck), "Value {0} clashed".FormatWith(toCheck)); permutes.Add(toCheck); } }); diff --git a/tests/Hydrogen.Tests/Threading/ProducerConsumerLockTests.cs b/tests/Hydrogen.Tests/Threading/ProducerConsumerLockTests.cs index 5aae1fed4..9b248afd8 100644 --- a/tests/Hydrogen.Tests/Threading/ProducerConsumerLockTests.cs +++ b/tests/Hydrogen.Tests/Threading/ProducerConsumerLockTests.cs @@ -26,7 +26,7 @@ // using (@lock.BlockUntil(ProducerConsumerType.Consumer, () => true)) { // result = 1; // } -// Assert.AreEqual(1, result); +// ClassicAssert.AreEqual(1, result); // } // [Test] @@ -95,7 +95,7 @@ // Volatile.Write(ref start, true); // @lock.Pulse(); // Thread.Sleep(200); -// Assert.AreEqual(new int[] { 1, 2 }, result.ToArray()); +// ClassicAssert.AreEqual(new int[] { 1, 2 }, result.ToArray()); // } @@ -130,19 +130,19 @@ // // Everything should be blocked // Thread.Sleep(100); -// Assert.AreEqual(Enumerable.Empty(), result); +// ClassicAssert.AreEqual(Enumerable.Empty(), result); // // Allow first two threads in // Volatile.Write(ref start, true); // @lock.Pulse(); // Thread.Sleep(100); -// Assert.AreEqual(new[] { 1, 2 }, result.ToArray()); +// ClassicAssert.AreEqual(new[] { 1, 2 }, result.ToArray()); // // Allow last two threads in // Volatile.Write(ref start, true); // @lock.Pulse(); // Thread.Sleep(100); -// Assert.AreEqual(new[] { 1, 2, 3, 4 }, result.ToArray()); +// ClassicAssert.AreEqual(new[] { 1, 2, 3, 4 }, result.ToArray()); // } @@ -178,7 +178,7 @@ // } // Thread.Sleep(100); -// Assert.AreEqual(Enumerable.Empty(), result); +// ClassicAssert.AreEqual(Enumerable.Empty(), result); // Volatile.Write(ref start, true); @@ -187,7 +187,7 @@ // Thread.Sleep(100); // } // Tools.NUnit.Print(result); -// Assert.AreEqual(Enumerable.Range(1, 100), result); +// ClassicAssert.AreEqual(Enumerable.Range(1, 100), result); // } // } diff --git a/tests/Hydrogen.Tests/Threading/SchedulerTest.cs b/tests/Hydrogen.Tests/Threading/SchedulerTest.cs index 569dc0fdc..a5f4af842 100644 --- a/tests/Hydrogen.Tests/Threading/SchedulerTest.cs +++ b/tests/Hydrogen.Tests/Threading/SchedulerTest.cs @@ -12,6 +12,7 @@ using NUnit.Framework; using System.Threading; using System.Linq; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -35,7 +36,7 @@ public async Task StartOn_LocalTime() { scheduler.Start(); await Task.Delay(TimeSpan.FromSeconds(1.5)); scheduler.Stop(); - Assert.AreEqual(1, count); + ClassicAssert.AreEqual(1, count); } [Test] @@ -48,7 +49,7 @@ public async Task StartOn_UtcTime() { scheduler.Start(); await Task.Delay(TimeSpan.FromSeconds(1.1)); scheduler.Stop(); - Assert.AreEqual(1, count); + ClassicAssert.AreEqual(1, count); } [Test] @@ -61,7 +62,7 @@ public async Task RepeatWithoutStartTime() { scheduler.Start(); await Task.Delay(TimeSpan.FromSeconds(1.1)); scheduler.Stop(); - Assert.AreEqual(1, count); // does not start straight away + ClassicAssert.AreEqual(1, count); // does not start straight away } @@ -75,7 +76,7 @@ public async Task AwaitsCorrectly_Simple() { scheduler.Start(); await Task.Delay(TimeSpan.FromSeconds(5.8)); scheduler.Stop(); - Assert.AreEqual(1 + 5, count); // Starts straight away + ClassicAssert.AreEqual(1 + 5, count); // Starts straight away } [Test] @@ -137,7 +138,7 @@ public async Task RescheduleOnStart() { await Task.Delay(TimeSpan.FromSeconds(3.8)); scheduler.Stop(); ThreadPool.SetMaxThreads(workerThreads, portThreads); - Assert.AreEqual(3, count); // Starts straight away + ClassicAssert.AreEqual(3, count); // Starts straight away } [Test] @@ -159,7 +160,7 @@ public async Task RescheduleOnFinish() { scheduler.Start(); await Task.Delay(TimeSpan.FromSeconds(1)); scheduler.Stop(); - Assert.AreEqual(1, count); // Starts straight away + ClassicAssert.AreEqual(1, count); // Starts straight away } [Test] @@ -188,10 +189,10 @@ public async Task ScheduleJob_OnIntervalJobWithEndDate_ShouldCompleteByEndDate() scheduler.Start(); await Task.Delay(TimeSpan.FromSeconds((executionCount * intervalSeconds) + 1)); - Assert.AreEqual(JobStatus.Completed, job.Status); + ClassicAssert.AreEqual(JobStatus.Completed, job.Status); scheduler.Stop(); - Assert.AreEqual(executionCount, count); + ClassicAssert.AreEqual(executionCount, count); } [Test] @@ -220,10 +221,10 @@ public async Task ScheduleJob_OnIntervalJobWithEndDate_ShouldCompleteByInterval( scheduler.Start(); await Task.Delay(TimeSpan.FromSeconds((executionCount * intervalSeconds) + 1)); - Assert.AreEqual(JobStatus.Completed, job.Status); + ClassicAssert.AreEqual(JobStatus.Completed, job.Status); scheduler.Stop(); - Assert.AreEqual(executionCount, count); + ClassicAssert.AreEqual(executionCount, count); } [Test] @@ -273,7 +274,7 @@ public async Task ScheduleJob_JobThrowsException_ShouldCallErrorHandler() { await Task.Delay(TimeSpan.FromSeconds(2)); scheduler.Stop(); - Assert.IsTrue(failException != null && failException.Message == SchedulerTestErrorJob.Errormessage); + ClassicAssert.IsTrue(failException != null && failException.Message == SchedulerTestErrorJob.Errormessage); } [Test] @@ -317,10 +318,10 @@ public static void CompareSchedulers(Scheduler scheduler, Scheduler convertedSch foreach (var job in scheduler.GetJobs()) { // Compare jobs. var convertedJob = convertedScheduler.GetJobs().FirstOrDefault(x => x.Name == job.Name); - Assert.IsNotNull(convertedJob); - Assert.AreEqual(job.Policy, convertedJob.Policy); - Assert.AreEqual(job.Status, convertedJob.Status); - Assert.AreEqual(job.Schedules.Count(), convertedJob.Schedules.Count()); + ClassicAssert.IsNotNull(convertedJob); + ClassicAssert.AreEqual(job.Policy, convertedJob.Policy); + ClassicAssert.AreEqual(job.Status, convertedJob.Status); + ClassicAssert.AreEqual(job.Schedules.Count(), convertedJob.Schedules.Count()); // Compare schedules. var schedules = job.Schedules.ToList(); @@ -330,13 +331,13 @@ public static void CompareSchedulers(Scheduler scheduler, Scheduler convertedSch var schedule = schedules[i]; var convertedSchedule = convertedSchedules[i]; - Assert.IsNotNull(convertedSchedule); - Assert.AreEqual(Truncate(schedule.LastStartTime), Truncate(convertedSchedule.LastStartTime)); - Assert.AreEqual(Truncate(schedule.LastEndTime), Truncate(convertedSchedule.LastEndTime)); - Assert.AreEqual(Truncate(schedule.EndDate), Truncate(convertedSchedule.EndDate)); - Assert.AreEqual(schedule.ReschedulePolicy, convertedSchedule.ReschedulePolicy); - Assert.AreEqual(schedule.IterationsRemaining, convertedSchedule.IterationsRemaining); - Assert.AreEqual(schedule.IterationsExecuted, convertedSchedule.IterationsExecuted); + ClassicAssert.IsNotNull(convertedSchedule); + ClassicAssert.AreEqual(Truncate(schedule.LastStartTime), Truncate(convertedSchedule.LastStartTime)); + ClassicAssert.AreEqual(Truncate(schedule.LastEndTime), Truncate(convertedSchedule.LastEndTime)); + ClassicAssert.AreEqual(Truncate(schedule.EndDate), Truncate(convertedSchedule.EndDate)); + ClassicAssert.AreEqual(schedule.ReschedulePolicy, convertedSchedule.ReschedulePolicy); + ClassicAssert.AreEqual(schedule.IterationsRemaining, convertedSchedule.IterationsRemaining); + ClassicAssert.AreEqual(schedule.IterationsExecuted, convertedSchedule.IterationsExecuted); } } diff --git a/tests/Hydrogen.Tests/Threading/ThroughputOptimizerTests.cs b/tests/Hydrogen.Tests/Threading/ThroughputOptimizerTests.cs index b48fb6c43..04b2ccf3f 100644 --- a/tests/Hydrogen.Tests/Threading/ThroughputOptimizerTests.cs +++ b/tests/Hydrogen.Tests/Threading/ThroughputOptimizerTests.cs @@ -8,6 +8,7 @@ using System; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests; @@ -26,14 +27,14 @@ public class ThroughputOptimizerTests { [TestCaseSource("TestParameters")] public void InitialDirection_1(long minSize, long maxSize, double adjustment, double tolerance) { var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); } [Test] [TestCaseSource("TestParameters")] public void InitialDirection_2(long minSize, long maxSize, double adjustment, double tolerance) { var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing, op.AdjustmentDirection); } [Test] @@ -46,14 +47,14 @@ public void InitialDirection_Throws(long minSize, long maxSize, double adjustmen [TestCaseSource("TestParameters")] public void InitialSize_1(long minSize, long maxSize, double adjustment, double tolerance) { var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); - Assert.AreEqual(1000, op.SuggestedBatchSize); + ClassicAssert.AreEqual(1000, op.SuggestedBatchSize); } [Test] [TestCaseSource("TestParameters")] public void InitialSize_2(long minSize, long maxSize, double adjustment, double tolerance) { var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing); - Assert.AreEqual(10000, op.SuggestedBatchSize); + ClassicAssert.AreEqual(10000, op.SuggestedBatchSize); } [Test] @@ -63,7 +64,7 @@ public void IgnoreSample_Simple_1(long minSize, long maxSize, double adjustment, var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); op.RegisterSample((long)Math.Round(minSize * (1 - (adjustment + tolerance + breach)).ClipTo(0, double.MaxValue), 0), TimeSpan.FromSeconds(1)); op.RegisterSample((long)Math.Round(minSize * (1 + (adjustment + tolerance + breach)).ClipTo(0, double.MaxValue), 0), TimeSpan.FromSeconds(1)); - Assert.AreEqual(op.SampleCount, 0); + ClassicAssert.AreEqual(op.SampleCount, 0); } [Test] @@ -73,7 +74,7 @@ public void IgnoreSample_Simple_2(long minSize, long maxSize, double adjustment, var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing); op.RegisterSample((long)Math.Round(maxSize * (1 - (adjustment + tolerance + breach)).ClipTo(0, double.MaxValue), 0), TimeSpan.FromSeconds(1)); op.RegisterSample((long)Math.Round(maxSize * (1 + (adjustment + tolerance + breach)).ClipTo(0, double.MaxValue), 0), TimeSpan.FromSeconds(1)); - Assert.AreEqual(op.SampleCount, 0); + ClassicAssert.AreEqual(op.SampleCount, 0); } [Test] @@ -81,8 +82,8 @@ public void IgnoreSample_Simple_2(long minSize, long maxSize, double adjustment, public void Increase_Simple(long minSize, long maxSize, double adjustment, double tolerance) { var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); op.RegisterSample(minSize, TimeSpan.FromSeconds(1)); - Assert.AreEqual(1, op.SampleCount); - Assert.AreEqual((long)Math.Round(minSize * (1 + adjustment), 0), op.SuggestedBatchSize); + ClassicAssert.AreEqual(1, op.SampleCount); + ClassicAssert.AreEqual((long)Math.Round(minSize * (1 + adjustment), 0), op.SuggestedBatchSize); } [Test] @@ -90,8 +91,8 @@ public void Increase_Simple(long minSize, long maxSize, double adjustment, doubl public void Decrease_Simple(long minSize, long maxSize, double adjustment, double tolerance) { var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing); op.RegisterSample(maxSize, TimeSpan.FromSeconds(1)); - Assert.AreEqual(1, op.SampleCount); - Assert.AreEqual((long)Math.Round(maxSize * (1 - adjustment), 0), op.SuggestedBatchSize); + ClassicAssert.AreEqual(1, op.SampleCount); + ClassicAssert.AreEqual((long)Math.Round(maxSize * (1 - adjustment), 0), op.SuggestedBatchSize); } [Test] @@ -103,10 +104,10 @@ public void Increase_TwoSamples(long minSize, long maxSize, double adjustment, d }; var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); op.RegisterSample(samples[0].Item1, samples[0].Item2); - Assert.AreEqual(1, op.SampleCount); + ClassicAssert.AreEqual(1, op.SampleCount); op.RegisterSample(samples[1].Item1, samples[1].Item2); - Assert.AreEqual(2, op.SampleCount); - Assert.AreEqual((long)Math.Round(samples[1].Item1 * (1 + adjustment), 0), op.SuggestedBatchSize); + ClassicAssert.AreEqual(2, op.SampleCount); + ClassicAssert.AreEqual((long)Math.Round(samples[1].Item1 * (1 + adjustment), 0), op.SuggestedBatchSize); } [Test] @@ -119,10 +120,10 @@ public void Decrease_TwoSamples(long minSize, long maxSize, double adjustment, d var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing); op.RegisterSample(samples[0].Item1, samples[0].Item2); - Assert.AreEqual(1, op.SampleCount); + ClassicAssert.AreEqual(1, op.SampleCount); op.RegisterSample(samples[1].Item1, samples[1].Item2); - Assert.AreEqual(2, op.SampleCount); - Assert.AreEqual((long)Math.Round(samples[1].Item1 * (1 - adjustment), 0), op.SuggestedBatchSize); + ClassicAssert.AreEqual(2, op.SampleCount); + ClassicAssert.AreEqual((long)Math.Round(samples[1].Item1 * (1 - adjustment), 0), op.SuggestedBatchSize); } [Test] @@ -137,22 +138,22 @@ public void FindOptimal_Increasing(long minSize, long maxSize, double adjustment var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); op.RegisterSample(samples[0].Item1, samples[0].Item2); - Assert.AreEqual(1, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(1, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); op.RegisterSample(samples[1].Item1, samples[1].Item2); - Assert.AreEqual(2, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(2, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); op.RegisterSample(samples[2].Item1, samples[2].Item2); - Assert.AreEqual(3, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(3, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); op.RegisterSample(samples[3].Item1, samples[3].Item2); - Assert.AreEqual(4, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(4, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples[2].Item1, op.SuggestedBatchSize); } @@ -168,22 +169,22 @@ public void FindOptimal_Decreasing(long minSize, long maxSize, double adjustment var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing); op.RegisterSample(samples[0].Item1, samples[0].Item2); - Assert.AreEqual(1, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(1, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing, op.AdjustmentDirection); op.RegisterSample(samples[1].Item1, samples[1].Item2); - Assert.AreEqual(2, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(2, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing, op.AdjustmentDirection); op.RegisterSample(samples[2].Item1, samples[2].Item2); - Assert.AreEqual(3, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(3, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing, op.AdjustmentDirection); op.RegisterSample(samples[3].Item1, samples[3].Item2); - Assert.AreEqual(4, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(4, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples[2].Item1, op.SuggestedBatchSize); } @@ -203,13 +204,13 @@ public void OptimalChanged_FasterBigger(long minSize, long maxSize, double adjus var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); samples.ForEach(s => op.RegisterSample(s.Item1, s.Item2)); - Assert.AreEqual(samples.Length, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples.Length, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); op.RegisterSample(lastSample.Item1, lastSample.Item2); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); Assert.That(Math.Round(lastSample.Item1 * (1.0 + adjustment), 0), Is.EqualTo(op.SuggestedBatchSize).Within(tolerance)); } @@ -229,13 +230,13 @@ public void OptimalChanged_FasterSame(long minSize, long maxSize, double adjustm var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); samples.ForEach(s => op.RegisterSample(s.Item1, s.Item2)); - Assert.AreEqual(samples.Length, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples.Length, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); op.RegisterSample(lastSample.Item1, lastSample.Item2); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); Assert.That(Math.Round(lastSample.Item1 * (1.0 + adjustment), 0), Is.EqualTo(op.SuggestedBatchSize).Within(tolerance)); } @@ -255,13 +256,13 @@ public void OptimalChanged_FasterSmaller(long minSize, long maxSize, double adju var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); samples.ForEach(s => op.RegisterSample(s.Item1, s.Item2)); - Assert.AreEqual(samples.Length, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples.Length, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); op.RegisterSample(lastSample.Item1, lastSample.Item2); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Decreasing, op.AdjustmentDirection); Assert.That(Math.Round(lastSample.Item1 * (1.0 - adjustment), 0), Is.EqualTo(op.SuggestedBatchSize).Within(tolerance)); } @@ -281,13 +282,13 @@ public void OptimalChanged_SameBigger(long minSize, long maxSize, double adjustm var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); samples.ForEach(s => op.RegisterSample(s.Item1, s.Item2)); - Assert.AreEqual(samples.Length, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples.Length, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); op.RegisterSample(lastSample.Item1, lastSample.Item2); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); Assert.That(Math.Round(lastSample.Item1 * (1.0 + adjustment), 0), Is.EqualTo(op.SuggestedBatchSize).Within(tolerance)); } @@ -307,14 +308,14 @@ public void OptimalChanged_SameSame(long minSize, long maxSize, double adjustmen var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); samples.ForEach(s => op.RegisterSample(s.Item1, s.Item2)); - Assert.AreEqual(samples.Length, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples.Length, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); op.RegisterSample(lastSample.Item1, lastSample.Item2); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); } [Test] @@ -333,14 +334,14 @@ public void OptimalChanged_SameSmaller(long minSize, long maxSize, double adjust var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); samples.ForEach(s => op.RegisterSample(s.Item1, s.Item2)); - Assert.AreEqual(samples.Length, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples.Length, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); op.RegisterSample(lastSample.Item1, lastSample.Item2); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); } [Test] @@ -359,14 +360,14 @@ public void OptimalChanged_SlowerBigger(long minSize, long maxSize, double adjus var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); samples.ForEach(s => op.RegisterSample(s.Item1, s.Item2)); - Assert.AreEqual(samples.Length, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples.Length, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); op.RegisterSample(lastSample.Item1, lastSample.Item2); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); } @@ -386,13 +387,13 @@ public void OptimalChanged_SlowerSame_1(long minSize, long maxSize, double adjus var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); samples.ForEach(s => op.RegisterSample(s.Item1, s.Item2)); - Assert.AreEqual(samples.Length, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples.Length, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); op.RegisterSample(lastSample.Item1, lastSample.Item2); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Increasing, op.AdjustmentDirection); Assert.That(Math.Round(samples[samples.Length - 2].Item1 * (1.0 + adjustment), 0), Is.EqualTo(op.SuggestedBatchSize).Within(tolerance)); } @@ -413,14 +414,14 @@ public void OptimalChanged_SlowerSmaller(long minSize, long maxSize, double adju var op = new ThroughputOptimizer(minSize, maxSize, adjustment, tolerance, ThroughputOptimizer.SamplingAdjustmentDirection.Increasing); samples.ForEach(s => op.RegisterSample(s.Item1, s.Item2)); - Assert.AreEqual(samples.Length, op.SampleCount); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(samples.Length, op.SampleCount); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); op.RegisterSample(lastSample.Item1, lastSample.Item2); - Assert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); - Assert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); + ClassicAssert.AreEqual(ThroughputOptimizer.SamplingAdjustmentDirection.Stablized, op.AdjustmentDirection); + ClassicAssert.AreEqual(samples[samples.Length - 2].Item1, op.SuggestedBatchSize); } diff --git a/tests/Hydrogen.Tests/Values/CVarIntTests.cs b/tests/Hydrogen.Tests/Values/CVarIntTests.cs index 3fb2b8840..b1d052995 100644 --- a/tests/Hydrogen.Tests/Values/CVarIntTests.cs +++ b/tests/Hydrogen.Tests/Values/CVarIntTests.cs @@ -10,6 +10,7 @@ using System.IO; using FluentAssertions; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests.Values; @@ -25,7 +26,7 @@ public void WriteAndRead(ulong value, int size, int expectedByteLength) { var stream = new MemoryStream(); var a = new CVarInt(value); a.Write(stream); - Assert.AreEqual(expectedByteLength, stream.Length); + ClassicAssert.AreEqual(expectedByteLength, stream.Length); stream.Seek(0, SeekOrigin.Begin); ulong b = CVarInt.Read(stream); @@ -43,7 +44,7 @@ public void ToAndFromBytes(ulong value, int size, int expectedByteLength) { var stream = new MemoryStream(); var a = new CVarInt(value); stream.Write(a.ToBytes()); - Assert.AreEqual(expectedByteLength, stream.Length); + ClassicAssert.AreEqual(expectedByteLength, stream.Length); ulong b = CVarInt.From(stream.ToArray()); b.Should().Be(a).And.Be(value); @@ -68,7 +69,7 @@ public void IntegrationTest([Values(1000000)] int iterations) { ulong val = (uint)rng.Next() + (uint)rng.Next(); CVarInt.Write(val, memStream); memStream.Seek(0, SeekOrigin.Begin); - Assert.AreEqual(val, CVarInt.Read(memStream)); + ClassicAssert.AreEqual(val, CVarInt.Read(memStream)); } } } diff --git a/tests/Hydrogen.Tests/Values/VarIntTests.cs b/tests/Hydrogen.Tests/Values/VarIntTests.cs index 23e87975e..55989abc3 100644 --- a/tests/Hydrogen.Tests/Values/VarIntTests.cs +++ b/tests/Hydrogen.Tests/Values/VarIntTests.cs @@ -10,6 +10,7 @@ using System.IO; using FluentAssertions; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace Hydrogen.Tests.Values; @@ -28,7 +29,7 @@ public void WriteAndReadStream(ulong value, int expectedByteLength) { var stream = new MemoryStream(); var a = new VarInt(value); a.Write(stream); - Assert.AreEqual(expectedByteLength, stream.Length); + ClassicAssert.AreEqual(expectedByteLength, stream.Length); stream.Seek(0, SeekOrigin.Begin); ulong b = VarInt.Read(stream); @@ -74,7 +75,7 @@ public void IntegrationTest([Values(1000000)] int iterations) { ulong val = (uint)rng.Next() + (uint)rng.Next(); VarInt.Write(val, memStream); memStream.Seek(0, SeekOrigin.Begin); - Assert.AreEqual(val, VarInt.Read(memStream)); + ClassicAssert.AreEqual(val, VarInt.Read(memStream)); } } diff --git a/tests/Hydrogen.Windows.LevelDB.Tests/LevelDBTests.cs b/tests/Hydrogen.Windows.LevelDB.Tests/LevelDBTests.cs index 086b1d3d7..c5077891f 100644 --- a/tests/Hydrogen.Windows.LevelDB.Tests/LevelDBTests.cs +++ b/tests/Hydrogen.Windows.LevelDB.Tests/LevelDBTests.cs @@ -12,6 +12,7 @@ using System.IO; using System.Linq; using Hydrogen.Windows.LevelDB; +using NUnit.Framework.Legacy; // ReSharper disable CheckNamespace @@ -32,11 +33,11 @@ static string CleanTestDB() { public void Intro() { using (var database = new DB("mytestdb", new Options() { CreateIfMissing = true })) { database.Put("key1", "value1"); - Assert.AreEqual("value1", database.Get("key1")); - Assert.IsTrue(database.Get("key1") != null); + ClassicAssert.AreEqual("value1", database.Get("key1")); + ClassicAssert.IsTrue(database.Get("key1") != null); database.Delete("key1"); - Assert.IsFalse(database.Get("key1") != null); - Assert.IsNull(database.Get("key1")); + ClassicAssert.IsFalse(database.Get("key1") != null); + ClassicAssert.IsNull(database.Get("key1")); } } @@ -63,13 +64,13 @@ public void TestCRUD() { db.Put("London", "red"); db.Put("New York", "blue"); - Assert.AreEqual(db.Get("Tampa"), "green"); - Assert.AreEqual(db.Get("London"), "red"); - Assert.AreEqual(db.Get("New York"), "blue"); + ClassicAssert.AreEqual(db.Get("Tampa"), "green"); + ClassicAssert.AreEqual(db.Get("London"), "red"); + ClassicAssert.AreEqual(db.Get("New York"), "blue"); db.Delete("New York"); - Assert.IsNull(db.Get("New York")); + ClassicAssert.IsNull(db.Get("New York")); db.Delete("New York"); } @@ -102,7 +103,7 @@ public void TestIterator() { } } - CollectionAssert.AreEqual(expected, actual); + ClassicAssert.AreEqual(expected, actual); } } @@ -120,7 +121,7 @@ public void TestEnumerable() { var actual = from kv in db as IEnumerable> select kv.Key; - CollectionAssert.AreEqual(expected, actual.ToArray()); + ClassicAssert.AreEqual(expected, actual.ToArray()); } } @@ -138,15 +139,15 @@ public void TestSnapshot() { db.Put("New York", "blue"); - Assert.AreEqual(db.Get("Tampa", readOptions), "green"); - Assert.AreEqual(db.Get("London", readOptions), "red"); + ClassicAssert.AreEqual(db.Get("Tampa", readOptions), "green"); + ClassicAssert.AreEqual(db.Get("London", readOptions), "red"); // Snapshot taken before key was updates - Assert.IsNull(db.Get("New York", readOptions)); + ClassicAssert.IsNull(db.Get("New York", readOptions)); } // can see the change now - Assert.AreEqual(db.Get("New York"), "blue"); + ClassicAssert.AreEqual(db.Get("New York"), "blue"); } } @@ -168,8 +169,8 @@ public void TestGetProperty() { var stats = db.PropertyValue("leveldb.stats"); - Assert.IsNotNull(stats); - Assert.IsTrue(stats.Contains("Compactions")); + ClassicAssert.IsNotNull(stats); + ClassicAssert.IsTrue(stats.Contains("Compactions")); } } @@ -192,7 +193,7 @@ public void TestWriteBatch() { var actual = from kv in db as IEnumerable> select kv.Key; - CollectionAssert.AreEqual(expected, actual.ToArray()); + ClassicAssert.AreEqual(expected, actual.ToArray()); } } } diff --git a/tests/Hydrogen.Windows.Tests/WindowsSecurityTest.cs b/tests/Hydrogen.Windows.Tests/WindowsSecurityTest.cs index f42dcefd2..6d307431e 100644 --- a/tests/Hydrogen.Windows.Tests/WindowsSecurityTest.cs +++ b/tests/Hydrogen.Windows.Tests/WindowsSecurityTest.cs @@ -12,6 +12,7 @@ using System.IO; using Hydrogen.Windows; using Hydrogen.Windows.Security; +using NUnit.Framework.Legacy; namespace Hydrogen.UnitTests; @@ -42,11 +43,11 @@ public void TestClass_NTRemoteObject() { WinAPI.ADVAPI32.SidNameUse.Domain ); - Assert.AreEqual(host.Name, obj.Host); - Assert.AreEqual("Domain", obj.Domain); - Assert.AreEqual("Name", obj.Name); - Assert.AreEqual(host.SID, obj.SID); - Assert.AreEqual(WinAPI.ADVAPI32.SidNameUse.Domain, obj.SidNameUsage); + ClassicAssert.AreEqual(host.Name, obj.Host); + ClassicAssert.AreEqual("Domain", obj.Domain); + ClassicAssert.AreEqual("Name", obj.Name); + ClassicAssert.AreEqual(host.SID, obj.SID); + ClassicAssert.AreEqual(WinAPI.ADVAPI32.SidNameUse.Domain, obj.SidNameUsage); } @@ -60,9 +61,9 @@ public void TestClass_NTDanglingObject() { "Name" ); - Assert.AreEqual(host.Name, obj.Host); - Assert.AreEqual("Name", obj.Name); - Assert.IsNull(obj.SID); + ClassicAssert.AreEqual(host.Name, obj.Host); + ClassicAssert.AreEqual("Name", obj.Name); + ClassicAssert.IsNull(obj.SID); } @@ -76,10 +77,10 @@ public void TestClass_NTDanglingObject2() { WinAPI.ADVAPI32.SidNameUse.Invalid ); - Assert.AreEqual(host.Name, obj.Host); - Assert.AreEqual(host.SID, obj.SID); - Assert.AreEqual(WinAPI.ADVAPI32.SidNameUse.Invalid, obj.NameUse); - Assert.AreEqual(string.Empty, obj.Name); + ClassicAssert.AreEqual(host.Name, obj.Host); + ClassicAssert.AreEqual(host.SID, obj.SID); + ClassicAssert.AreEqual(WinAPI.ADVAPI32.SidNameUse.Invalid, obj.NameUse); + ClassicAssert.AreEqual(string.Empty, obj.Name); } #endregion @@ -89,20 +90,20 @@ public void TestClass_NTDanglingObject2() { [Test] public void TestLocalHost() { NTHost host = NTHost.CurrentMachine; - Assert.IsNotNull(host); - Assert.AreEqual(host.Name.ToUpper(), Environment.MachineName.ToUpper()); + ClassicAssert.IsNotNull(host); + ClassicAssert.AreEqual(host.Name.ToUpper(), Environment.MachineName.ToUpper()); } [Test] public void TestLocalHostGetSid() { NTHost host = NTHost.CurrentMachine; - Assert.IsNotNull(host.SID); + ClassicAssert.IsNotNull(host.SID); } [Test] public void TestLocalHostGetAdministratorUser() { NTHost host = NTHost.CurrentMachine; - Assert.IsTrue( + ClassicAssert.IsTrue( ContainsSid( new SecurityIdentifier(WellKnownSidType.AccountAdministratorSid, host.SID), host.GetLocalUsers() @@ -114,13 +115,13 @@ public void TestLocalHostGetAdministratorUser() { public void TestLocalHostAdministratorUserPrivilege() { NTHost host = NTHost.CurrentMachine; NTLocalUser user = GetObjectByName(host.GetLocalUsers(), "Administrator"); - Assert.IsTrue(user.Privilege == UserPrivilege.Admin); + ClassicAssert.IsTrue(user.Privilege == UserPrivilege.Admin); } [Test] public void TestLocalHostGetGuest() { NTHost host = NTHost.CurrentMachine; - Assert.IsTrue( + ClassicAssert.IsTrue( ContainsSid( new SecurityIdentifier(WellKnownSidType.AccountGuestSid, host.SID), host.GetLocalUsers() @@ -136,7 +137,7 @@ public void TestLocalHostGetAdministratorsGroup() { NTLocalGroup group = GetObjectByName(localGroups, "Administrators"); SecurityIdentifier localHostSid = host.SID; SecurityIdentifier adminSid = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, localHostSid); - Assert.IsTrue( + ClassicAssert.IsTrue( ContainsSid( adminSid, host.GetLocalGroups() @@ -147,7 +148,7 @@ public void TestLocalHostGetAdministratorsGroup() { [Test] public void TestLocalHostGetGuestsGroup() { NTHost host = NTHost.CurrentMachine; - Assert.IsTrue( + ClassicAssert.IsTrue( ContainsSid( new SecurityIdentifier(WellKnownSidType.BuiltinGuestsSid, null), host.GetLocalGroups() @@ -158,7 +159,7 @@ public void TestLocalHostGetGuestsGroup() { [Test] public void TestLocalHostGetPowerUsersGroup() { NTHost host = NTHost.CurrentMachine; - Assert.IsTrue( + ClassicAssert.IsTrue( ContainsSid( new SecurityIdentifier(WellKnownSidType.BuiltinPowerUsersSid, null), host.GetLocalGroups() @@ -172,10 +173,10 @@ public void TestLocalUserCreateDelete() { // find a unique user name string userName = GenerateUserName(host); NTLocalUser user = host.CreateLocalUser(userName, "pPnNmm*&"); - Assert.IsNotNull(user); - Assert.IsTrue(ContainsObjectByName(host.GetLocalUsers(), userName)); + ClassicAssert.IsNotNull(user); + ClassicAssert.IsTrue(ContainsObjectByName(host.GetLocalUsers(), userName)); user.Delete(); - Assert.IsFalse(ContainsObjectByName(host.GetLocalUsers(), userName)); + ClassicAssert.IsFalse(ContainsObjectByName(host.GetLocalUsers(), userName)); } [Test] @@ -185,7 +186,7 @@ public void TestLocalUserUpdateSID() { string userName = GenerateUserName(host); NTLocalUser user = host.CreateLocalUser(userName, "pPnNmm*&"); try { - Assert.IsNotNull(user.SID); + ClassicAssert.IsNotNull(user.SID); } finally { user.Delete(); } @@ -198,7 +199,7 @@ public void TestLocalUserSIDContainsHostSID() { string userName = GenerateUserName(host); NTLocalUser user = host.CreateLocalUser(userName, "pPnNmm*&"); try { - Assert.AreEqual(user.SID.AccountDomainSid, host.SID); + ClassicAssert.AreEqual(user.SID.AccountDomainSid, host.SID); } finally { user.Delete(); } @@ -215,7 +216,7 @@ public void TestLocalUserUpdateHomeDirectory() { user.HomeDirectory = value; user.Update(); user = GetObjectByName(host.GetLocalUsers(), userName); - Assert.AreEqual(user.HomeDirectory, value); + ClassicAssert.AreEqual(user.HomeDirectory, value); } finally { user.Delete(); } @@ -231,7 +232,7 @@ public void TestLocalUserUpdateLastLogoff() { try { user.Update(); user = GetObjectByName(host.GetLocalUsers(), userName); - Assert.AreEqual(value, user.LastLogoff); + ClassicAssert.AreEqual(value, user.LastLogoff); } finally { user.Delete(); } @@ -247,7 +248,7 @@ public void TestLocalUserUpdateLastLogon() { try { user.Update(); user = GetObjectByName(host.GetLocalUsers(), userName); - Assert.AreEqual(value, user.LastLogon); + ClassicAssert.AreEqual(value, user.LastLogon); } finally { user.Delete(); } @@ -263,7 +264,7 @@ public void TestLocalUserUpdateLogonHours() { user.LogonHours = value; user.Update(); user = GetObjectByName(host.GetLocalUsers(), userName); - CollectionAssert.AreEqual(user.LogonHours, value); + ClassicAssert.AreEqual(user.LogonHours, value); user.Delete(); } @@ -274,7 +275,7 @@ public void TestLocalUserUpdateLogonServer() { string userName = GenerateUserName(host); NTLocalUser user = host.CreateLocalUser(userName, "pPnNmm*&"); try { - Assert.AreEqual("\\\\*", user.LogonServer); + ClassicAssert.AreEqual("\\\\*", user.LogonServer); } finally { user.Delete(); } @@ -292,7 +293,7 @@ public void TestLocalUserUpdateMaxStorage() { user.MaxStorage = value; user.Update(); user = GetObjectByName(host.GetLocalUsers(), userName); - Assert.AreEqual(value, user.MaxStorage); + ClassicAssert.AreEqual(value, user.MaxStorage); } finally { user.Delete(); } @@ -305,7 +306,7 @@ public void TestLocalUserUpdateName() { string userName = GenerateUserName(host); NTLocalUser user = host.CreateLocalUser(userName, "pPnNmm*&"); try { - Assert.AreEqual(user.Name, userName); + ClassicAssert.AreEqual(user.Name, userName); } finally { user.Delete(); } @@ -318,7 +319,7 @@ public void TestLocalUserUpdateNumberOfLogons() { string userName = GenerateUserName(host); NTLocalUser user = host.CreateLocalUser(userName, "pPnNmm*&"); try { - Assert.AreEqual(user.NumberOfLogons, 0); + ClassicAssert.AreEqual(user.NumberOfLogons, 0); } finally { user.Delete(); } @@ -343,7 +344,7 @@ public void TestLocalUserUpdatePasswordAge() { string userName = GenerateUserName(host); NTLocalUser user = host.CreateLocalUser(userName, "pPnNmm*&"); try { - Assert.IsTrue(0 <= user.PasswordAge.TotalSeconds && user.PasswordAge.TotalSeconds <= 2); + ClassicAssert.IsTrue(0 <= user.PasswordAge.TotalSeconds && user.PasswordAge.TotalSeconds <= 2); } finally { user.Delete(); } @@ -356,7 +357,7 @@ public void TestLocalUserUpdatePrivilege() { string userName = GenerateUserName(host); NTLocalUser user = host.CreateLocalUser(userName, "pPnNmm*&"); try { - Assert.AreEqual(user.Privilege, UserPrivilege.Guest); + ClassicAssert.AreEqual(user.Privilege, UserPrivilege.Guest); } finally { user.Delete(); } @@ -373,7 +374,7 @@ public void TestLocalUserUpdateScriptPath() { user.ScriptPath = value; user.Update(); user = GetObjectByName(host.GetLocalUsers(), userName); - Assert.AreEqual(user.ScriptPath, value); + ClassicAssert.AreEqual(user.ScriptPath, value); } finally { user.Delete(); } @@ -391,7 +392,7 @@ public void TestLocalGetUserUnitsPerWeek() { user.UnitsPerWeek = value; user.Update(); user = GetObjectByName(host.GetLocalUsers(), userName); - Assert.AreEqual(user.UnitsPerWeek, value); + ClassicAssert.AreEqual(user.UnitsPerWeek, value); } finally { user.Delete(); } @@ -408,7 +409,7 @@ public void TestLocalUserGetWorkstations() { user.Workstations = value; user.Update(); user = GetObjectByName(host.GetLocalUsers(), userName); - CollectionAssert.AreEqual(user.Workstations, value); + ClassicAssert.AreEqual(user.Workstations, value); } finally { user.Delete(); } @@ -442,7 +443,7 @@ public void TestLocalUserWithSingleGroup() { group = host.CreateLocalGroup(GenerateGroupName(host), null); user = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); user.AddMembership(group.Name); - Assert.IsTrue(ContainsObjectByName(user.GetMembership(), group.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(user.GetMembership(), group.Name)); } finally { try { if (user != null) { @@ -471,11 +472,11 @@ public void TestLocalUsersWithMultipleGroups() { NTLocalGroup group3 = null; try { group1 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group1); + ClassicAssert.IsNotNull(group1); group2 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group2); + ClassicAssert.IsNotNull(group2); group3 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group3); + ClassicAssert.IsNotNull(group3); user1 = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); @@ -487,16 +488,16 @@ public void TestLocalUsersWithMultipleGroups() { user2.AddMembership(group3.Name); NTLocalGroup[] user1Membership = user1.GetMembership(); - Assert.IsNotNull(user1Membership); + ClassicAssert.IsNotNull(user1Membership); - Assert.IsTrue(ContainsObjectByName(user1Membership, group1.Name)); - Assert.IsTrue(ContainsObjectByName(user1Membership, group2.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(user1Membership, group1.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(user1Membership, group2.Name)); NTLocalGroup[] user2Membership = user2.GetMembership(); - Assert.IsNotNull(user2Membership); + ClassicAssert.IsNotNull(user2Membership); - Assert.IsTrue(ContainsObjectByName(user2Membership, group1.Name)); - Assert.IsTrue(ContainsObjectByName(user2Membership, group3.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(user2Membership, group1.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(user2Membership, group3.Name)); } finally { try { @@ -543,10 +544,10 @@ public void TestLocalGroupCreateDelete() { NTHost host = NTHost.CurrentMachine; string groupName = GenerateGroupName(host); NTLocalGroup group = host.CreateLocalGroup(groupName, null); - Assert.IsNotNull(group); - Assert.IsTrue(ContainsObjectByName(host.GetLocalGroups(), groupName)); + ClassicAssert.IsNotNull(group); + ClassicAssert.IsTrue(ContainsObjectByName(host.GetLocalGroups(), groupName)); group.Delete(); - Assert.IsFalse(ContainsObjectByName(host.GetLocalGroups(), groupName)); + ClassicAssert.IsFalse(ContainsObjectByName(host.GetLocalGroups(), groupName)); } [Test] @@ -557,7 +558,7 @@ public void TestLocalGroupGetDescription() { NTLocalGroup group = host.CreateLocalGroup(groupName, description); try { group = GetObjectByName(host.GetLocalGroups(), groupName); - Assert.AreEqual(description, group.Description); + ClassicAssert.AreEqual(description, group.Description); } finally { group.Delete(); } @@ -574,7 +575,7 @@ public void TestLocalGroupUpdateDescription() { group.Description = newDescription; group.Update(); group = GetObjectByName(host.GetLocalGroups(), groupName); - Assert.AreEqual(newDescription, group.Description); + ClassicAssert.AreEqual(newDescription, group.Description); } finally { group.Delete(); } @@ -608,7 +609,7 @@ public void TestLocalGroupAddMember() { group = host.CreateLocalGroup(GenerateGroupName(host), null); user = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); group.AddLocalMember(user.Name); - Assert.IsTrue(ContainsObjectByName(group.GetLocalMembers(), user.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(group.GetLocalMembers(), user.Name)); } finally { try { if (user != null) { @@ -636,7 +637,7 @@ public void TestLocalGroupDeleteByObject() { group = host.CreateLocalGroup(GenerateGroupName(host), null); user = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); group.AddLocalMember(user.Name); - Assert.IsTrue(ContainsObjectByName(group.GetLocalMembers(), user.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(group.GetLocalMembers(), user.Name)); group.DeleteMember(user); CollectionAssert.IsEmpty(group.GetLocalMembers()); } finally { @@ -666,7 +667,7 @@ public void TestLocalGroupDeleteBySID() { group = host.CreateLocalGroup(GenerateGroupName(host), null); user = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); group.AddLocalMember(user.Name); - Assert.IsTrue(ContainsObjectByName(group.GetLocalMembers(), user.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(group.GetLocalMembers(), user.Name)); group.DeleteMember(user.SID); CollectionAssert.IsEmpty(group.GetLocalMembers()); } finally { @@ -696,7 +697,7 @@ public void TestLocalGroupDeleteByName() { group = host.CreateLocalGroup(GenerateGroupName(host), null); user = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); group.AddLocalMember(user.Name); - Assert.IsTrue(ContainsObjectByName(group.GetLocalMembers(), user.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(group.GetLocalMembers(), user.Name)); group.DeleteLocalMember(user.Name); CollectionAssert.IsEmpty(group.GetLocalMembers()); } finally { @@ -727,11 +728,11 @@ public void TestLocalGroupWithMultipleMembersWithUserMembershipVerify() { NTLocalGroup group3 = null; try { group1 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group1); + ClassicAssert.IsNotNull(group1); group2 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group2); + ClassicAssert.IsNotNull(group2); group3 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group3); + ClassicAssert.IsNotNull(group3); user1 = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); @@ -743,16 +744,16 @@ public void TestLocalGroupWithMultipleMembersWithUserMembershipVerify() { group3.AddLocalMember(user2.Name); NTLocalGroup[] user1Membership = user1.GetMembership(); - Assert.IsNotNull(user1Membership); + ClassicAssert.IsNotNull(user1Membership); - Assert.IsTrue(ContainsObjectByName(user1Membership, group1.Name)); - Assert.IsTrue(ContainsObjectByName(user1Membership, group2.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(user1Membership, group1.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(user1Membership, group2.Name)); NTLocalGroup[] user2Membership = user2.GetMembership(); - Assert.IsNotNull(user2Membership); + ClassicAssert.IsNotNull(user2Membership); - Assert.IsTrue(ContainsObjectByName(user2Membership, group1.Name)); - Assert.IsTrue(ContainsObjectByName(user2Membership, group3.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(user2Membership, group1.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(user2Membership, group3.Name)); } finally { try { @@ -805,11 +806,11 @@ public void TestLocalGroupWithMultipleMembersWithWithGroupMembershipVerify() { NTLocalGroup group3 = null; try { group1 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group1); + ClassicAssert.IsNotNull(group1); group2 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group2); + ClassicAssert.IsNotNull(group2); group3 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group3); + ClassicAssert.IsNotNull(group3); user1 = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); @@ -821,20 +822,20 @@ public void TestLocalGroupWithMultipleMembersWithWithGroupMembershipVerify() { group3.AddLocalMember(user2.Name); NTLocalObject[] group1Members = group1.GetLocalMembers(); - Assert.IsNotNull(group1Members); - Assert.AreEqual(2, group1Members.Length); - Assert.IsTrue(ContainsObjectByName(group1Members, user1.Name)); - Assert.IsTrue(ContainsObjectByName(group1Members, user2.Name)); + ClassicAssert.IsNotNull(group1Members); + ClassicAssert.AreEqual(2, group1Members.Length); + ClassicAssert.IsTrue(ContainsObjectByName(group1Members, user1.Name)); + ClassicAssert.IsTrue(ContainsObjectByName(group1Members, user2.Name)); NTLocalObject[] group2Members = group2.GetLocalMembers(); - Assert.IsNotNull(group2Members); - Assert.AreEqual(1, group2Members.Length); - Assert.IsTrue(ContainsObjectByName(group2Members, user1.Name)); + ClassicAssert.IsNotNull(group2Members); + ClassicAssert.AreEqual(1, group2Members.Length); + ClassicAssert.IsTrue(ContainsObjectByName(group2Members, user1.Name)); NTLocalObject[] group3Members = group3.GetLocalMembers(); - Assert.IsNotNull(group3Members); - Assert.AreEqual(1, group3Members.Length); - Assert.IsTrue(ContainsObjectByName(group3Members, user2.Name)); + ClassicAssert.IsNotNull(group3Members); + ClassicAssert.AreEqual(1, group3Members.Length); + ClassicAssert.IsTrue(ContainsObjectByName(group3Members, user2.Name)); } finally { try { @@ -887,11 +888,11 @@ public void TestLocalGroupDeleteMultipleMembersWithWithUserMembershipVerify() { NTLocalGroup group3 = null; try { group1 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group1); + ClassicAssert.IsNotNull(group1); group2 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group2); + ClassicAssert.IsNotNull(group2); group3 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group3); + ClassicAssert.IsNotNull(group3); user1 = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); user2 = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); @@ -908,12 +909,12 @@ public void TestLocalGroupDeleteMultipleMembersWithWithUserMembershipVerify() { NTLocalGroup[] user1Membership = user1.GetMembership(); - Assert.IsNotNull(user1Membership); - Assert.AreEqual(0, user1Membership.Length); + ClassicAssert.IsNotNull(user1Membership); + ClassicAssert.AreEqual(0, user1Membership.Length); NTLocalGroup[] user2Membership = user2.GetMembership(); - Assert.IsNotNull(user2Membership); - Assert.AreEqual(0, user2Membership.Length); + ClassicAssert.IsNotNull(user2Membership); + ClassicAssert.AreEqual(0, user2Membership.Length); } finally { try { @@ -966,11 +967,11 @@ public void TestLocalGroupDeleteMultipleMembersWithWithGroupMembershipVerify() { NTLocalGroup group3 = null; try { group1 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group1); + ClassicAssert.IsNotNull(group1); group2 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group2); + ClassicAssert.IsNotNull(group2); group3 = host.CreateLocalGroup(GenerateGroupName(host), "description"); - Assert.IsNotNull(group3); + ClassicAssert.IsNotNull(group3); user1 = host.CreateLocalUser(GenerateUserName(host), "pPnNmm*&"); @@ -988,16 +989,16 @@ public void TestLocalGroupDeleteMultipleMembersWithWithGroupMembershipVerify() { NTObject[] group1Members = group1.GetMembers(); - Assert.IsNotNull(group1Members); - Assert.AreEqual(0, group1Members.Length); + ClassicAssert.IsNotNull(group1Members); + ClassicAssert.AreEqual(0, group1Members.Length); NTObject[] group2Members = group2.GetMembers(); - Assert.IsNotNull(group2Members); - Assert.AreEqual(0, group2Members.Length); + ClassicAssert.IsNotNull(group2Members); + ClassicAssert.AreEqual(0, group2Members.Length); NTObject[] group3Members = group3.GetMembers(); - Assert.IsNotNull(group3Members); - Assert.AreEqual(0, group3Members.Length); + ClassicAssert.IsNotNull(group3Members); + ClassicAssert.AreEqual(0, group3Members.Length); } finally { try { @@ -1046,20 +1047,20 @@ public void TestLocalGroupDeleteMultipleMembersWithWithGroupMembershipVerify() { [Test] public void TestRemoteHost() { NTHost host = new NTHost(RemoteHostName); - Assert.IsNotNull(host); - Assert.AreEqual(RemoteHostName.ToUpper(), host.Name.ToUpper()); + ClassicAssert.IsNotNull(host); + ClassicAssert.AreEqual(RemoteHostName.ToUpper(), host.Name.ToUpper()); } [Test] public void TestRemoteHostGetSid() { NTHost host = new NTHost(RemoteHostName); - Assert.IsNotNull(host.SID); + ClassicAssert.IsNotNull(host.SID); } [Test] public void TestRemoteHostGetAdministratorUser() { NTHost host = new NTHost(RemoteHostName); - Assert.IsTrue( + ClassicAssert.IsTrue( ContainsSid( new SecurityIdentifier(WellKnownSidType.AccountAdministratorSid, host.SID), host.GetLocalUsers() @@ -1071,13 +1072,13 @@ public void TestRemoteHostGetAdministratorUser() { public void TestRemoteHostAdministratorUserPrivilege() { NTHost host = new NTHost(RemoteHostName); NTLocalUser user = GetObjectByName(host.GetLocalUsers(), "Administrator"); - Assert.IsTrue(user.Privilege == UserPrivilege.Admin); + ClassicAssert.IsTrue(user.Privilege == UserPrivilege.Admin); } [Test] public void TestRemoteHostGetGuest() { NTHost host = new NTHost(RemoteHostName); - Assert.IsTrue( + ClassicAssert.IsTrue( ContainsSid( new SecurityIdentifier(WellKnownSidType.AccountGuestSid, host.SID), host.GetLocalUsers() @@ -1093,7 +1094,7 @@ public void TestRemoteHostGetAdministratorsGroup() { NTLocalGroup group = GetObjectByName(localGroups, "Administrators"); SecurityIdentifier localHostSid = host.SID; SecurityIdentifier adminSid = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, localHostSid); - Assert.IsTrue( + ClassicAssert.IsTrue( ContainsSid( adminSid, host.GetLocalGroups() @@ -1107,7 +1108,7 @@ public void TestRemoteHostGetAdministratorsGroupMembers() { NTLocalGroup[] localGroups = host.GetLocalGroups(); NTLocalGroup group = GetObjectByName(localGroups, "Administrators"); NTLocalObject[] members = group.GetLocalMembers(); - Assert.IsNotNull(members); + ClassicAssert.IsNotNull(members); CollectionAssert.IsNotEmpty(members); } @@ -1115,7 +1116,7 @@ public void TestRemoteHostGetAdministratorsGroupMembers() { [Test] public void TestRemoteHostGetGuestsGroup() { NTHost host = new NTHost(RemoteHostName); - Assert.IsTrue( + ClassicAssert.IsTrue( ContainsSid( new SecurityIdentifier(WellKnownSidType.BuiltinGuestsSid, null), host.GetLocalGroups() @@ -1126,7 +1127,7 @@ public void TestRemoteHostGetGuestsGroup() { [Test] public void TestRemoteHostGetPowerUsersGroup() { NTHost host = new NTHost(RemoteHostName); - Assert.IsTrue( + ClassicAssert.IsTrue( ContainsSid( new SecurityIdentifier(WellKnownSidType.BuiltinPowerUsersSid, null), host.GetLocalGroups()