Skip to content

UnitTests: Use proper 'Assert' methods after adding lots of new code. #4122

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Aug 8, 2025
Merged

UnitTests: Use proper 'Assert' methods after adding lots of new code. #4122

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
18 changes: 9 additions & 9 deletions tests/Neo.ConsoleService.Tests/UT_CommandServiceBase.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -63,7 +63,7 @@ public void TestParseIndicatorArguments()

// Test case 1: Basic indicator arguments
var args1 = "test --strParam hello --intParam 42 --boolParam".Tokenize();
Assert.AreEqual(11, args1.Count);
Assert.HasCount(11, args1);
Assert.AreEqual("test", args1[0].Value);
Assert.AreEqual("--strParam", args1[2].Value);
Assert.AreEqual("hello", args1[4].Value);
Expand All @@ -72,10 +72,10 @@ public void TestParseIndicatorArguments()
Assert.AreEqual("--boolParam", args1[10].Value);

var result1 = service.ParseIndicatorArguments(method, args1[1..]);
Assert.AreEqual(4, result1.Length);
Assert.HasCount(4, result1);
Assert.AreEqual("hello", result1[0]);
Assert.AreEqual(42u, result1[1]);
Assert.AreEqual(true, result1[2]);
Assert.IsTrue((bool?)result1[2]);
Assert.AreEqual("default", result1[3]); // Default value

// Test case 2: Boolean parameter without value
Expand All @@ -86,7 +86,7 @@ public void TestParseIndicatorArguments()
var enumMethod = typeof(TestConsoleService).GetMethod("TestEnumMethod");
var args3 = "testenum --enumParam Value2".Tokenize();
var result3 = service.ParseIndicatorArguments(enumMethod, args3[1..]);
Assert.AreEqual(1, result3.Length);
Assert.HasCount(1, result3);
Assert.AreEqual(TestConsoleService.TestEnum.Value2, result3[0]);

// Test case 4: Unknown parameter should throw exception
Expand All @@ -107,26 +107,26 @@ public void TestParseSequentialArguments()
// Test case 1: All parameters provided
var args1 = "test hello 42 true custom".Tokenize();
var result1 = service.ParseSequentialArguments(method, args1[1..]);
Assert.AreEqual(4, result1.Length);
Assert.HasCount(4, result1);
Assert.AreEqual("hello", result1[0]);
Assert.AreEqual(42u, result1[1]);
Assert.AreEqual(true, result1[2]);
Assert.IsTrue((bool?)result1[2]);
Assert.AreEqual("custom", result1[3]);

// Test case 2: Some parameters with default values
var args2 = "test hello 42 true".Tokenize();
var result2 = service.ParseSequentialArguments(method, args2[1..]);
Assert.AreEqual(4, result2.Length);
Assert.HasCount(4, result2);
Assert.AreEqual("hello", result2[0]);
Assert.AreEqual(42u, result2[1]);
Assert.AreEqual(true, result2[2]);
Assert.IsTrue((bool?)result2[2]);
Assert.AreEqual("default", result2[3]); // optionalParam default value

// Test case 3: Enum parameter
var enumMethod = typeof(TestConsoleService).GetMethod("TestEnumMethod");
var args3 = "testenum Value1".Tokenize();
var result3 = service.ParseSequentialArguments(enumMethod, args3[1..].Trim());
Assert.AreEqual(1, result3.Length);
Assert.HasCount(1, result3);
Assert.AreEqual(TestConsoleService.TestEnum.Value1, result3[0]);

// Test case 4: Missing required parameter should throw exception
Expand Down
44 changes: 22 additions & 22 deletions tests/Neo.ConsoleService.Tests/UT_CommandTokenizer.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,7 +22,7 @@ public void Test1()
{
var cmd = " ";
var args = cmd.Tokenize();
Assert.AreEqual(1, args.Count);
Assert.HasCount(1, args);
Assert.AreEqual(" ", args[0].Value);
}

Expand All @@ -31,7 +31,7 @@ public void Test2()
{
var cmd = "show state";
var args = cmd.Tokenize();
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("state", args[2].Value);
Expand All @@ -43,7 +43,7 @@ public void Test3()
{
var cmd = "show \"hello world\"";
var args = cmd.Tokenize();
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("hello world", args[2].Value);
Expand All @@ -54,7 +54,7 @@ public void Test4()
{
var cmd = "show \"'\"";
var args = cmd.Tokenize();
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("'", args[2].Value);
Expand All @@ -65,7 +65,7 @@ public void Test5()
{
var cmd = "show \"123\\\"456\""; // Double quote because it is quoted twice in code and command.
var args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("123\"456", args[2].Value);
Expand All @@ -77,15 +77,15 @@ public void TestMore()
{
var cmd = "show 'x1,x2,x3'";
var args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("x1,x2,x3", args[2].Value);
Assert.AreEqual("'x1,x2,x3'", args[2].RawValue);

cmd = "show '\\n \\r \\t \\''"; // Double quote because it is quoted twice in code and command.
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("\n \r \t \'", args[2].Value);
Expand All @@ -97,7 +97,7 @@ public void TestMore()
var json = "[{\"type\":\"Hash160\",\"value\":\"0x0010922195a6c7cab3233f923716ad8e2dd63f8a\"}]";
cmd = "invoke 0xef4073a0f2b305a38ec4050e4d3d28bc40ea63f5 balanceOf " + json;
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(7, args.Count);
Assert.HasCount(7, args);
Assert.AreEqual("invoke", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("0xef4073a0f2b305a38ec4050e4d3d28bc40ea63f5", args[2].Value);
Expand All @@ -108,7 +108,7 @@ public void TestMore()

cmd = "show x'y'";
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("x'y'", args[2].Value);
Expand All @@ -120,23 +120,23 @@ public void TestBackQuote()
{
var cmd = "show `x`";
var args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("x", args[2].Value);
Assert.AreEqual("`x`", args[2].RawValue);

cmd = "show `{\"a\": \"b\"}`";
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("{\"a\": \"b\"}", args[2].Value);
Assert.AreEqual("`{\"a\": \"b\"}`", args[2].RawValue);

cmd = "show `123\"456`"; // Donot quoted twice if the input uses backquote.
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("123\"456", args[2].Value);
Expand All @@ -149,30 +149,30 @@ public void TestUnicodeEscape()
// Test basic Unicode escape sequence
var cmd = "show \"\\u0041\""; // Should decode to 'A'
var args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("A", args[2].Value);

// Test Unicode escape sequence for emoji
cmd = "show \"\\uD83D\\uDE00\""; // Should decode to 😀
args = CommandTokenizer.Tokenize(cmd); // surrogate pairs
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("😀", args[2].Value);

// Test Unicode escape sequence in single quotes
cmd = "show '\\u0048\\u0065\\u006C\\u006C\\u006F'"; // Should decode to "Hello"
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("Hello", args[2].Value);

cmd = "show '\\x48\\x65\\x6C\\x6C\\x6F'"; // Should decode to "Hello"
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("Hello", args[2].Value);
Expand All @@ -197,47 +197,47 @@ public void TestUnicodeEdgeCases()
// Test surrogate pairs - high surrogate
var cmd = "show \"\\uD83D\"";
var args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("\uD83D", args[2].Value); // High surrogate

// Test surrogate pairs - low surrogate
cmd = "show \"\\uDE00\"";
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("\uDE00", args[2].Value); // Low surrogate

// Test null character
cmd = "show \"\\u0000\"";
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("\u0000", args[2].Value); // Null character

// Test maximum Unicode value
cmd = "show \"\\uFFFF\"";
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("\uFFFF", args[2].Value); // Maximum Unicode value

// Test multiple Unicode escapes in sequence
cmd = "show \"\\u0048\\u0065\\u006C\\u006C\\u006F\\u0020\\u0057\\u006F\\u0072\\u006C\\u0064\"";
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("Hello World", args[2].Value);

// Test Unicode escape mixed with regular characters
cmd = "show \"Hello\\u0020World\"";
args = CommandTokenizer.Tokenize(cmd);
Assert.AreEqual(3, args.Count);
Assert.HasCount(3, args);
Assert.AreEqual("show", args[0].Value);
Assert.AreEqual(" ", args[1].Value);
Assert.AreEqual("Hello World", args[2].Value);
Expand Down
2 changes: 1 addition & 1 deletion tests/Neo.Cryptography.MPTTrie.Tests/Cryptography/MPTTrie/UT_Node.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -222,7 +222,7 @@ public void TestEmptyLeaf()
{
var leaf = Node.NewLeaf(Array.Empty<byte>());
var data = leaf.ToArray();
Assert.AreEqual(3, data.Length);
Assert.HasCount(3, data);
var l = data.AsSerializable<Node>();
Assert.AreEqual(NodeType.LeafNode, l.Type);
Assert.AreEqual(0, l.Value.Length);
Expand Down
50 changes: 25 additions & 25 deletions tests/Neo.Cryptography.MPTTrie.Tests/Cryptography/MPTTrie/UT_Trie.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -279,20 +279,20 @@ public void TestGetProof()
Assert.AreEqual(r.Hash.ToString(), mpt.Root.Hash.ToString());
var result = mpt.TryGetProof("ac01".HexToBytes(), out var proof);
Assert.IsTrue(result);
Assert.AreEqual(4, proof.Count);
Assert.IsTrue(proof.Contains(b.ToArrayWithoutReference()));
Assert.IsTrue(proof.Contains(r.ToArrayWithoutReference()));
Assert.IsTrue(proof.Contains(e1.ToArrayWithoutReference()));
Assert.IsTrue(proof.Contains(v1.ToArrayWithoutReference()));
Assert.HasCount(4, proof);
Assert.Contains(b.ToArrayWithoutReference(), proof);
Assert.Contains(r.ToArrayWithoutReference(), proof);
Assert.Contains(e1.ToArrayWithoutReference(), proof);
Assert.Contains(v1.ToArrayWithoutReference(), proof);

result = mpt.TryGetProof("ac".HexToBytes(), out proof);
Assert.AreEqual(3, proof.Count);
Assert.HasCount(3, proof);

result = mpt.TryGetProof("ac10".HexToBytes(), out proof);
Assert.IsFalse(result);

result = mpt.TryGetProof("acae".HexToBytes(), out proof);
Assert.AreEqual(4, proof.Count);
Assert.HasCount(4, proof);

Assert.ThrowsExactly<ArgumentException>(() => _ = mpt.TryGetProof([], out proof));

Expand Down Expand Up @@ -334,13 +334,13 @@ public void TestSplitKey()
mpt1.Put([0xab], [0x02]);
var r = mpt1.TryGetProof([0xab, 0xcd], out var set1);
Assert.IsTrue(r);
Assert.AreEqual(4, set1.Count);
Assert.HasCount(4, set1);
var mpt2 = new Trie(snapshot, null);
mpt2.Put([0xab], [0x02]);
mpt2.Put([0xab, 0xcd], [0x01]);
r = mpt2.TryGetProof([0xab, 0xcd], out var set2);
Assert.IsTrue(r);
Assert.AreEqual(4, set2.Count);
Assert.HasCount(4, set2);
Assert.AreEqual(mpt1.Root.Hash, mpt2.Root.Hash);
}

Expand All @@ -351,21 +351,21 @@ public void TestFind()
var snapshot = store.GetSnapshot();
var mpt1 = new Trie(snapshot, null);
var results = mpt1.Find([]).ToArray();
Assert.AreEqual(0, results.Length);
Assert.IsEmpty(results);
var mpt2 = new Trie(snapshot, null);
mpt2.Put([0xab, 0xcd, 0xef], [0x01]);
mpt2.Put([0xab, 0xcd, 0xe1], [0x02]);
mpt2.Put([0xab], [0x03]);
results = [.. mpt2.Find([])];
Assert.AreEqual(3, results.Length);
Assert.HasCount(3, results);
results = [.. mpt2.Find([0xab])];
Assert.AreEqual(3, results.Length);
Assert.HasCount(3, results);
results = [.. mpt2.Find([0xab, 0xcd])];
Assert.AreEqual(2, results.Length);
Assert.HasCount(2, results);
results = [.. mpt2.Find([0xac])];
Assert.AreEqual(0, results.Length);
Assert.IsEmpty(results);
results = [.. mpt2.Find([0xab, 0xcd, 0xef, 0x00])];
Assert.AreEqual(0, results.Length);
Assert.IsEmpty(results);
}

[TestMethod]
Expand Down Expand Up @@ -399,7 +399,7 @@ public void TestFindLeadNode()
var mpt = new Trie(_mptdb.GetSnapshot(), _root.Hash);
var prefix = new byte[] { 0xac, 0x01 }; // = FromNibbles(path = { 0x0a, 0x0c, 0x00, 0x01 });
var results = mpt.Find(prefix).ToArray();
Assert.AreEqual(1, results.Length);
Assert.HasCount(1, results);

prefix = [0xac]; // = FromNibbles(path = { 0x0a, 0x0c });
Assert.ThrowsExactly<InvalidOperationException>(() => _ = mpt.Find(prefix).ToArray());
Expand Down Expand Up @@ -551,12 +551,12 @@ public void TestEmptyValueIssue633()
mpt.Put(key, []);
var val = mpt[key];
Assert.IsNotNull(val);
Assert.AreEqual(0, val.Length);
Assert.IsEmpty(val);
var r = mpt.TryGetProof(key, out var proof);
Assert.IsTrue(r);
val = Trie.VerifyProof(mpt.Root.Hash, key, proof);
Assert.IsNotNull(val);
Assert.AreEqual(0, val.Length);
Assert.IsEmpty(val);
}

[TestMethod]
Expand All @@ -568,13 +568,13 @@ public void TestFindWithFrom()
mpt.Put("aa10".HexToBytes(), "03".HexToBytes());
mpt.Put("aa50".HexToBytes(), "04".HexToBytes());
var r = mpt.Find("aa".HexToBytes()).ToList();
Assert.AreEqual(3, r.Count);
Assert.HasCount(3, r);
r = [.. mpt.Find("aa".HexToBytes(), "aa30".HexToBytes())];
Assert.AreEqual(1, r.Count);
Assert.HasCount(1, r);
r = [.. mpt.Find("aa".HexToBytes(), "aa60".HexToBytes())];
Assert.AreEqual(0, r.Count);
Assert.IsEmpty(r);
r = [.. mpt.Find("aa".HexToBytes(), "aa10".HexToBytes())];
Assert.AreEqual(1, r.Count);
Assert.HasCount(1, r);
}

[TestMethod]
Expand All @@ -585,11 +585,11 @@ public void TestFindStatesIssue652()
mpt.Put("abc1".HexToBytes(), "01".HexToBytes());
mpt.Put("abc3".HexToBytes(), "02".HexToBytes());
var r = mpt.Find("ab".HexToBytes(), "abd2".HexToBytes()).ToList();
Assert.AreEqual(0, r.Count);
Assert.IsEmpty(r);
r = [.. mpt.Find("ab".HexToBytes(), "abb2".HexToBytes())];
Assert.AreEqual(2, r.Count);
Assert.HasCount(2, r);
r = [.. mpt.Find("ab".HexToBytes(), "abc2".HexToBytes())];
Assert.AreEqual(1, r.Count);
Assert.HasCount(1, r);
}
}
}
Loading
Loading