11888209959

Committed 18 Nov 2024 08:06AM UTC coverage: 55.548% (-0.002%) from 55.55%

Build # 11888209959

Build Type

Pull #3454

github

Committed by

web-flow

Commit Message

Merge 650c9e956 into a72a0c951

Pull Request Pull Request #3454: Add hardofork HF_Echidna

Run Details

5867 of 9124 branches covered (64.3%)

Branch coverage included in aggregate %.

15 of 44 new or added lines in 4 files covered. (34.09%)

943 existing lines in 21 files now uncovered.

21891 of 40847 relevant lines covered (53.59%)

84888.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/tests/Neo.UnitTests/SmartContract/Native/UT_StdLib.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// UT_StdLib.cs file belongs to the neo project and is free
// software distributed under the MIT software license, see the
// accompanying file LICENSE in the main directory of the
// repository or http://www.opensource.org/licenses/mit-license.php
// for more details.
//
// Redistribution and use in source and binary forms with or without
// modifications are permitted.

using FluentAssertions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Neo.Extensions;
using Neo.SmartContract;
using Neo.SmartContract.Native;
using Neo.VM;
using Neo.VM.Types;
using System.Collections.Generic;
using System.Numerics;

namespace Neo.UnitTests.SmartContract.Native
{
    [TestClass]
    public class UT_StdLib
    {
        [TestMethod]
        public void TestBinary()
        {
            var data = System.Array.Empty<byte>();

            CollectionAssert.AreEqual(data, StdLib.Base64Decode(StdLib.Base64Encode(data)));
            CollectionAssert.AreEqual(data, StdLib.Base58Decode(StdLib.Base58Encode(data)));

            data = new byte[] { 1, 2, 3 };

            CollectionAssert.AreEqual(data, StdLib.Base64Decode(StdLib.Base64Encode(data)));
            CollectionAssert.AreEqual(data, StdLib.Base58Decode(StdLib.Base58Encode(data)));
            Assert.AreEqual("AQIDBA==", StdLib.Base64Encode(new byte[] { 1, 2, 3, 4 }));
            Assert.AreEqual("2VfUX", StdLib.Base58Encode(new byte[] { 1, 2, 3, 4 }));
        }

        [TestMethod]
        public void TestItoaAtoi()
        {
            Assert.AreEqual("1", StdLib.Itoa(BigInteger.One, 10));
            Assert.AreEqual("1", StdLib.Itoa(BigInteger.One, 16));
            Assert.AreEqual("-1", StdLib.Itoa(BigInteger.MinusOne, 10));
            Assert.AreEqual("f", StdLib.Itoa(BigInteger.MinusOne, 16));
            Assert.AreEqual("3b9aca00", StdLib.Itoa(1_000_000_000, 16));
            Assert.AreEqual(-1, StdLib.Atoi("-1", 10));
            Assert.AreEqual(1, StdLib.Atoi("+1", 10));
            Assert.AreEqual(-1, StdLib.Atoi("ff", 16));
            Assert.AreEqual(-1, StdLib.Atoi("FF", 16));
            Assert.ThrowsException<System.FormatException>(() => StdLib.Atoi("a", 10));
            Assert.ThrowsException<System.FormatException>(() => StdLib.Atoi("g", 16));
            Assert.ThrowsException<System.ArgumentOutOfRangeException>(() => StdLib.Atoi("a", 11));

            StdLib.Atoi(StdLib.Itoa(BigInteger.One, 10)).Should().Be(BigInteger.One);
            StdLib.Atoi(StdLib.Itoa(BigInteger.MinusOne, 10)).Should().Be(BigInteger.MinusOne);
        }

        [TestMethod]
        public void MemoryCompare()
        {
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();

            using (var script = new ScriptBuilder())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memoryCompare", "abc", "c");
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memoryCompare", "abc", "d");
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memoryCompare", "abc", "abc");
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memoryCompare", "abc", "abcd");

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.HALT);
                Assert.AreEqual(4, engine.ResultStack.Count);

                Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(0, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());
            }
        }

        [TestMethod]
        public void CheckDecodeEncode()
        {
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();

            using (ScriptBuilder script = new())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "base58CheckEncode", new byte[] { 1, 2, 3 });

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.HALT);
                Assert.AreEqual(1, engine.ResultStack.Count);

                Assert.AreEqual("3DUz7ncyT", engine.ResultStack.Pop<ByteString>().GetString());
            }

            using (ScriptBuilder script = new())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "base58CheckDecode", "3DUz7ncyT");

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.HALT);
                Assert.AreEqual(1, engine.ResultStack.Count);

                CollectionAssert.AreEqual(new byte[] { 1, 2, 3 }, engine.ResultStack.Pop<ByteString>().GetSpan().ToArray());
            }

            // Error

            using (ScriptBuilder script = new())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "base58CheckDecode", "AA");

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.FAULT);
            }

            using (ScriptBuilder script = new())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "base58CheckDecode", null);

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.FAULT);
            }
        }

        [TestMethod]
        public void MemorySearch()
        {
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();

            using (var script = new ScriptBuilder())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 0);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 1);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 2);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 3);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "d", 0);

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.HALT);
                Assert.AreEqual(5, engine.ResultStack.Count);

                Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(2, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(2, engine.ResultStack.Pop<Integer>().GetInteger());
            }

            using (var script = new ScriptBuilder())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 0, false);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 1, false);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 2, false);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 3, false);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "d", 0, false);

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.HALT);
                Assert.AreEqual(5, engine.ResultStack.Count);

                Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(2, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(2, engine.ResultStack.Pop<Integer>().GetInteger());
            }

            using (var script = new ScriptBuilder())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 0, true);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 1, true);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 2, true);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 3, true);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "d", 0, true);

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.HALT);
                Assert.AreEqual(5, engine.ResultStack.Count);

                Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(2, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());
                Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());
            }
        }

        [TestMethod]
        public void StringSplit()
        {
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();

            using var script = new ScriptBuilder();
            script.EmitDynamicCall(NativeContract.StdLib.Hash, "stringSplit", "a,b", ",");

            using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
            engine.LoadScript(script.ToArray());

            Assert.AreEqual(engine.Execute(), VMState.HALT);
            Assert.AreEqual(1, engine.ResultStack.Count);

            var arr = engine.ResultStack.Pop<Array>();
            Assert.AreEqual(2, arr.Count);
            Assert.AreEqual("a", arr[0].GetString());
            Assert.AreEqual("b", arr[1].GetString());
        }

        [TestMethod]
        public void StringElementLength()
        {
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();

            using var script = new ScriptBuilder();
            script.EmitDynamicCall(NativeContract.StdLib.Hash, "strLen", "🦆");
            script.EmitDynamicCall(NativeContract.StdLib.Hash, "strLen", "ã");
            script.EmitDynamicCall(NativeContract.StdLib.Hash, "strLen", "a");

            using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
            engine.LoadScript(script.ToArray());

            Assert.AreEqual(engine.Execute(), VMState.HALT);
            Assert.AreEqual(3, engine.ResultStack.Count);
            Assert.AreEqual(1, engine.ResultStack.Pop().GetInteger());
            Assert.AreEqual(1, engine.ResultStack.Pop().GetInteger());
            Assert.AreEqual(1, engine.ResultStack.Pop().GetInteger());
        }

        [TestMethod]
        public void TestInvalidUtf8Sequence()
        {
            // Simulating invalid UTF-8 byte (0xff) decoded as a UTF-16 char
            const char badChar = (char)0xff;
            var badStr = badChar.ToString();
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();

            using var script = new ScriptBuilder();
            script.EmitDynamicCall(NativeContract.StdLib.Hash, "strLen", badStr);
            script.EmitDynamicCall(NativeContract.StdLib.Hash, "strLen", badStr + "ab");

            using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
            engine.LoadScript(script.ToArray());

            Assert.AreEqual(engine.Execute(), VMState.HALT);
            Assert.AreEqual(2, engine.ResultStack.Count);
            Assert.AreEqual(3, engine.ResultStack.Pop().GetInteger());
            Assert.AreEqual(1, engine.ResultStack.Pop().GetInteger());
        }

        [TestMethod]
        public void Json_Deserialize()
        {
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();

            // Good

            using (var script = new ScriptBuilder())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonDeserialize", "123");
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonDeserialize", "null");

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.HALT);
                Assert.AreEqual(2, engine.ResultStack.Count);

                engine.ResultStack.Pop<Null>();
                Assert.IsTrue(engine.ResultStack.Pop().GetInteger() == 123);
            }

            // Error 1 - Wrong Json

            using (ScriptBuilder script = new())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonDeserialize", "***");

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.FAULT);
                Assert.AreEqual(0, engine.ResultStack.Count);
            }

            // Error 2 - No decimals

            using (var script = new ScriptBuilder())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonDeserialize", "123.45");

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.FAULT);
                Assert.AreEqual(0, engine.ResultStack.Count);
            }
        }

        [TestMethod]
        public void Json_Serialize()
        {
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();

            // Good

            using (var script = new ScriptBuilder())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize", 5);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize", true);
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize", "test");
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize", new object[] { null });
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize", new ContractParameter(ContractParameterType.Map)
                {
                    Value = new List<KeyValuePair<ContractParameter, ContractParameter>>() {
                        { new KeyValuePair<ContractParameter, ContractParameter>(
                            new ContractParameter(ContractParameterType.String){ Value="key" },
                            new ContractParameter(ContractParameterType.String){ Value= "value" })
                        }
                    }
                });

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.HALT);
                Assert.AreEqual(5, engine.ResultStack.Count);

                Assert.IsTrue(engine.ResultStack.Pop<ByteString>().GetString() == "{\"key\":\"value\"}");
                Assert.IsTrue(engine.ResultStack.Pop<ByteString>().GetString() == "null");
                Assert.IsTrue(engine.ResultStack.Pop<ByteString>().GetString() == "\"test\"");
                Assert.IsTrue(engine.ResultStack.Pop<ByteString>().GetString() == "true");
                Assert.IsTrue(engine.ResultStack.Pop<ByteString>().GetString() == "5");
            }

            // Error

            using (var script = new ScriptBuilder())
            {
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize");

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.FAULT);
                Assert.AreEqual(0, engine.ResultStack.Count);
            }
        }

        [TestMethod]
        public void TestRuntime_Serialize()
        {
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();

            // Good

            using ScriptBuilder script = new();
            script.EmitDynamicCall(NativeContract.StdLib.Hash, "serialize", 100);
            script.EmitDynamicCall(NativeContract.StdLib.Hash, "serialize", "test");

            using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
            engine.LoadScript(script.ToArray());

            Assert.AreEqual(engine.Execute(), VMState.HALT);
            Assert.AreEqual(2, engine.ResultStack.Count);

            Assert.AreEqual(engine.ResultStack.Pop<ByteString>().GetSpan().ToHexString(), "280474657374");
            Assert.AreEqual(engine.ResultStack.Pop<ByteString>().GetSpan().ToHexString(), "210164");
        }

        [TestMethod]
        public void TestRuntime_Deserialize()
        {
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();

            // Good

            using ScriptBuilder script = new();
            script.EmitDynamicCall(NativeContract.StdLib.Hash, "deserialize", "280474657374".HexToBytes());
            script.EmitDynamicCall(NativeContract.StdLib.Hash, "deserialize", "210164".HexToBytes());

            using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
            engine.LoadScript(script.ToArray());

            Assert.AreEqual(engine.Execute(), VMState.HALT);
            Assert.AreEqual(2, engine.ResultStack.Count);

            Assert.AreEqual(engine.ResultStack.Pop<Integer>().GetInteger(), 100);
            Assert.AreEqual(engine.ResultStack.Pop<ByteString>().GetString(), "test");
        }

        [TestMethod]
        public void TestBase64Url()
        {
            var snapshotCache = TestBlockchain.GetTestSnapshotCache();
            using (var script = new ScriptBuilder())
            {
                // Test encoding
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "base64UrlEncode", "Subject=test@example.com&Issuer=https://example.com");
                script.EmitDynamicCall(NativeContract.StdLib.Hash, "base64UrlDecode", "U3ViamVjdD10ZXN0QGV4YW1wbGUuY29tJklzc3Vlcj1odHRwczovL2V4YW1wbGUuY29t");

                using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);
                engine.LoadScript(script.ToArray());

                Assert.AreEqual(engine.Execute(), VMState.HALT);
                Assert.AreEqual(2, engine.ResultStack.Count);
                Assert.AreEqual("Subject=test@example.com&Issuer=https://example.com", engine.ResultStack.Pop<ByteString>());
                Assert.AreEqual("U3ViamVjdD10ZXN0QGV4YW1wbGUuY29tJklzc3Vlcj1odHRwczovL2V4YW1wbGUuY29t", engine.ResultStack.Pop<ByteString>().GetString());
            }
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// UT_StdLib.cs file belongs to the neo project and is free
4	// software distributed under the MIT software license, see the
5	// accompanying file LICENSE in the main directory of the
6	// repository or http://www.opensource.org/licenses/mit-license.php
7	// for more details.
8	//
9	// Redistribution and use in source and binary forms with or without
10	// modifications are permitted.
11
12	using FluentAssertions;
13	using Microsoft.VisualStudio.TestTools.UnitTesting;
14	using Neo.Extensions;
15	using Neo.SmartContract;
16	using Neo.SmartContract.Native;
17	using Neo.VM;
18	using Neo.VM.Types;
19	using System.Collections.Generic;
20	using System.Numerics;
21
22	namespace Neo.UnitTests.SmartContract.Native
23	{
24	[TestClass]
25	public class UT_StdLib
26	{
27	[TestMethod]
28	public void TestBinary()
29	{	×
30	var data = System.Array.Empty<byte>();	×
31
32	CollectionAssert.AreEqual(data, StdLib.Base64Decode(StdLib.Base64Encode(data)));	×
33	CollectionAssert.AreEqual(data, StdLib.Base58Decode(StdLib.Base58Encode(data)));	×
34
35	data = new byte[] { 1, 2, 3 };	×
36
37	CollectionAssert.AreEqual(data, StdLib.Base64Decode(StdLib.Base64Encode(data)));	×
38	CollectionAssert.AreEqual(data, StdLib.Base58Decode(StdLib.Base58Encode(data)));	×
39	Assert.AreEqual("AQIDBA==", StdLib.Base64Encode(new byte[] { 1, 2, 3, 4 }));	×
40	Assert.AreEqual("2VfUX", StdLib.Base58Encode(new byte[] { 1, 2, 3, 4 }));	×
41	}	×
42
43	[TestMethod]
44	public void TestItoaAtoi()
45	{	×
46	Assert.AreEqual("1", StdLib.Itoa(BigInteger.One, 10));	×
47	Assert.AreEqual("1", StdLib.Itoa(BigInteger.One, 16));	×
48	Assert.AreEqual("-1", StdLib.Itoa(BigInteger.MinusOne, 10));	×
49	Assert.AreEqual("f", StdLib.Itoa(BigInteger.MinusOne, 16));	×
50	Assert.AreEqual("3b9aca00", StdLib.Itoa(1_000_000_000, 16));	×
51	Assert.AreEqual(-1, StdLib.Atoi("-1", 10));	×
52	Assert.AreEqual(1, StdLib.Atoi("+1", 10));	×
53	Assert.AreEqual(-1, StdLib.Atoi("ff", 16));	×
54	Assert.AreEqual(-1, StdLib.Atoi("FF", 16));	×
55	Assert.ThrowsException<System.FormatException>(() => StdLib.Atoi("a", 10));	×
56	Assert.ThrowsException<System.FormatException>(() => StdLib.Atoi("g", 16));	×
57	Assert.ThrowsException<System.ArgumentOutOfRangeException>(() => StdLib.Atoi("a", 11));	×
58
59	StdLib.Atoi(StdLib.Itoa(BigInteger.One, 10)).Should().Be(BigInteger.One);	×
60	StdLib.Atoi(StdLib.Itoa(BigInteger.MinusOne, 10)).Should().Be(BigInteger.MinusOne);	×
61	}	×
62
63	[TestMethod]
64	public void MemoryCompare()
65	{	×
66	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
67
68	using (var script = new ScriptBuilder())	×
69	{	×
70	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memoryCompare", "abc", "c");	×
71	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memoryCompare", "abc", "d");	×
72	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memoryCompare", "abc", "abc");	×
73	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memoryCompare", "abc", "abcd");	×
74
75	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
76	engine.LoadScript(script.ToArray());	×
77
78	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
79	Assert.AreEqual(4, engine.ResultStack.Count);	×
80
81	Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());	×
82	Assert.AreEqual(0, engine.ResultStack.Pop<Integer>().GetInteger());	×
83	Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());	×
84	Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());	×
85	}	×
86	}	×
87
88	[TestMethod]
89	public void CheckDecodeEncode()
90	{	×
91	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
92
93	using (ScriptBuilder script = new())	×
94	{	×
95	script.EmitDynamicCall(NativeContract.StdLib.Hash, "base58CheckEncode", new byte[] { 1, 2, 3 });	×
96
97	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
98	engine.LoadScript(script.ToArray());	×
99
100	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
101	Assert.AreEqual(1, engine.ResultStack.Count);	×
102
103	Assert.AreEqual("3DUz7ncyT", engine.ResultStack.Pop<ByteString>().GetString());	×
104	}	×
105
106	using (ScriptBuilder script = new())	×
107	{	×
108	script.EmitDynamicCall(NativeContract.StdLib.Hash, "base58CheckDecode", "3DUz7ncyT");	×
109
110	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
111	engine.LoadScript(script.ToArray());	×
112
113	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
114	Assert.AreEqual(1, engine.ResultStack.Count);	×
115
116	CollectionAssert.AreEqual(new byte[] { 1, 2, 3 }, engine.ResultStack.Pop<ByteString>().GetSpan().ToArray());	×
117	}	×
118
119	// Error
120
121	using (ScriptBuilder script = new())	×
122	{	×
123	script.EmitDynamicCall(NativeContract.StdLib.Hash, "base58CheckDecode", "AA");	×
124
125	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
126	engine.LoadScript(script.ToArray());	×
127
128	Assert.AreEqual(engine.Execute(), VMState.FAULT);	×
129	}	×
130
131	using (ScriptBuilder script = new())	×
132	{	×
133	script.EmitDynamicCall(NativeContract.StdLib.Hash, "base58CheckDecode", null);	×
134
135	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
136	engine.LoadScript(script.ToArray());	×
137
138	Assert.AreEqual(engine.Execute(), VMState.FAULT);	×
139	}	×
140	}	×
141
142	[TestMethod]
143	public void MemorySearch()
144	{	×
145	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
146
147	using (var script = new ScriptBuilder())	×
148	{	×
149	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 0);	×
150	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 1);	×
151	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 2);	×
152	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 3);	×
153	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "d", 0);	×
154
155	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
156	engine.LoadScript(script.ToArray());	×
157
158	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
159	Assert.AreEqual(5, engine.ResultStack.Count);	×
160
161	Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());	×
162	Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());	×
163	Assert.AreEqual(2, engine.ResultStack.Pop<Integer>().GetInteger());	×
164	Assert.AreEqual(2, engine.ResultStack.Pop<Integer>().GetInteger());	×
165	}	×
166
167	using (var script = new ScriptBuilder())	×
168	{	×
169	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 0, false);	×
170	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 1, false);	×
171	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 2, false);	×
172	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 3, false);	×
173	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "d", 0, false);	×
174
175	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
176	engine.LoadScript(script.ToArray());	×
177
178	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
179	Assert.AreEqual(5, engine.ResultStack.Count);	×
180
181	Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());	×
182	Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());	×
183	Assert.AreEqual(2, engine.ResultStack.Pop<Integer>().GetInteger());	×
184	Assert.AreEqual(2, engine.ResultStack.Pop<Integer>().GetInteger());	×
185	}	×
186
187	using (var script = new ScriptBuilder())	×
188	{	×
189	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 0, true);	×
190	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 1, true);	×
191	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 2, true);	×
192	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "c", 3, true);	×
193	script.EmitDynamicCall(NativeContract.StdLib.Hash, "memorySearch", "abc", "d", 0, true);	×
194
195	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
196	engine.LoadScript(script.ToArray());	×
197
198	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
199	Assert.AreEqual(5, engine.ResultStack.Count);	×
200
201	Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());	×
202	Assert.AreEqual(2, engine.ResultStack.Pop<Integer>().GetInteger());	×
203	Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());	×
204	Assert.AreEqual(-1, engine.ResultStack.Pop<Integer>().GetInteger());	×
205	}	×
206	}	×
207
208	[TestMethod]
209	public void StringSplit()
210	{	×
211	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
212
213	using var script = new ScriptBuilder();	×
214	script.EmitDynamicCall(NativeContract.StdLib.Hash, "stringSplit", "a,b", ",");	×
215
216	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
217	engine.LoadScript(script.ToArray());	×
218
219	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
220	Assert.AreEqual(1, engine.ResultStack.Count);	×
221
222	var arr = engine.ResultStack.Pop<Array>();	×
223	Assert.AreEqual(2, arr.Count);	×
224	Assert.AreEqual("a", arr[0].GetString());	×
225	Assert.AreEqual("b", arr[1].GetString());	×
226	}	×
227
228	[TestMethod]
229	public void StringElementLength()
230	{	×
231	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
232
233	using var script = new ScriptBuilder();	×
234	script.EmitDynamicCall(NativeContract.StdLib.Hash, "strLen", "🦆");	×
235	script.EmitDynamicCall(NativeContract.StdLib.Hash, "strLen", "ã");	×
236	script.EmitDynamicCall(NativeContract.StdLib.Hash, "strLen", "a");	×
237
238	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
239	engine.LoadScript(script.ToArray());	×
240
241	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
242	Assert.AreEqual(3, engine.ResultStack.Count);	×
243	Assert.AreEqual(1, engine.ResultStack.Pop().GetInteger());	×
244	Assert.AreEqual(1, engine.ResultStack.Pop().GetInteger());	×
245	Assert.AreEqual(1, engine.ResultStack.Pop().GetInteger());	×
246	}	×
247
248	[TestMethod]
249	public void TestInvalidUtf8Sequence()
250	{	×
251	// Simulating invalid UTF-8 byte (0xff) decoded as a UTF-16 char
252	const char badChar = (char)0xff;
253	var badStr = badChar.ToString();	×
254	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
255
256	using var script = new ScriptBuilder();	×
257	script.EmitDynamicCall(NativeContract.StdLib.Hash, "strLen", badStr);	×
258	script.EmitDynamicCall(NativeContract.StdLib.Hash, "strLen", badStr + "ab");	×
259
260	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
261	engine.LoadScript(script.ToArray());	×
262
263	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
264	Assert.AreEqual(2, engine.ResultStack.Count);	×
265	Assert.AreEqual(3, engine.ResultStack.Pop().GetInteger());	×
266	Assert.AreEqual(1, engine.ResultStack.Pop().GetInteger());	×
267	}	×
268
269	[TestMethod]
270	public void Json_Deserialize()
271	{	×
272	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
273
274	// Good
275
276	using (var script = new ScriptBuilder())	×
277	{	×
278	script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonDeserialize", "123");	×
279	script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonDeserialize", "null");	×
280
281	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
282	engine.LoadScript(script.ToArray());	×
283
284	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
285	Assert.AreEqual(2, engine.ResultStack.Count);	×
286
287	engine.ResultStack.Pop<Null>();	×
288	Assert.IsTrue(engine.ResultStack.Pop().GetInteger() == 123);	×
289	}	×
290
291	// Error 1 - Wrong Json
292
293	using (ScriptBuilder script = new())	×
294	{	×
295	script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonDeserialize", "***");	×
296
297	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
298	engine.LoadScript(script.ToArray());	×
299
300	Assert.AreEqual(engine.Execute(), VMState.FAULT);	×
301	Assert.AreEqual(0, engine.ResultStack.Count);	×
302	}	×
303
304	// Error 2 - No decimals
305
306	using (var script = new ScriptBuilder())	×
307	{	×
308	script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonDeserialize", "123.45");	×
309
310	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
311	engine.LoadScript(script.ToArray());	×
312
313	Assert.AreEqual(engine.Execute(), VMState.FAULT);	×
314	Assert.AreEqual(0, engine.ResultStack.Count);	×
315	}	×
316	}	×
317
318	[TestMethod]
319	public void Json_Serialize()
320	{	×
321	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
322
323	// Good
324
325	using (var script = new ScriptBuilder())	×
326	{	×
327	script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize", 5);	×
328	script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize", true);	×
329	script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize", "test");	×
330	script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize", new object[] { null });	×
331	script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize", new ContractParameter(ContractParameterType.Map)	×
332	{	×
333	Value = new List<KeyValuePair<ContractParameter, ContractParameter>>() {	×
334	{ new KeyValuePair<ContractParameter, ContractParameter>(	×
335	new ContractParameter(ContractParameterType.String){ Value="key" },	×
336	new ContractParameter(ContractParameterType.String){ Value= "value" })	×
337	}	×
338	}	×
339	});	×
340
341	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
342	engine.LoadScript(script.ToArray());	×
343
344	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
345	Assert.AreEqual(5, engine.ResultStack.Count);	×
346
347	Assert.IsTrue(engine.ResultStack.Pop<ByteString>().GetString() == "{\"key\":\"value\"}");	×
348	Assert.IsTrue(engine.ResultStack.Pop<ByteString>().GetString() == "null");	×
349	Assert.IsTrue(engine.ResultStack.Pop<ByteString>().GetString() == "\"test\"");	×
350	Assert.IsTrue(engine.ResultStack.Pop<ByteString>().GetString() == "true");	×
351	Assert.IsTrue(engine.ResultStack.Pop<ByteString>().GetString() == "5");	×
352	}	×
353
354	// Error
355
356	using (var script = new ScriptBuilder())	×
357	{	×
358	script.EmitDynamicCall(NativeContract.StdLib.Hash, "jsonSerialize");	×
359
360	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
361	engine.LoadScript(script.ToArray());	×
362
363	Assert.AreEqual(engine.Execute(), VMState.FAULT);	×
364	Assert.AreEqual(0, engine.ResultStack.Count);	×
365	}	×
366	}	×
367
368	[TestMethod]
369	public void TestRuntime_Serialize()
370	{	×
371	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
372
373	// Good
374
375	using ScriptBuilder script = new();	×
376	script.EmitDynamicCall(NativeContract.StdLib.Hash, "serialize", 100);	×
377	script.EmitDynamicCall(NativeContract.StdLib.Hash, "serialize", "test");	×
378
379	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
380	engine.LoadScript(script.ToArray());	×
381
382	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
383	Assert.AreEqual(2, engine.ResultStack.Count);	×
384
385	Assert.AreEqual(engine.ResultStack.Pop<ByteString>().GetSpan().ToHexString(), "280474657374");	×
386	Assert.AreEqual(engine.ResultStack.Pop<ByteString>().GetSpan().ToHexString(), "210164");	×
387	}	×
388
389	[TestMethod]
390	public void TestRuntime_Deserialize()
391	{	×
392	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
393
394	// Good
395
396	using ScriptBuilder script = new();	×
397	script.EmitDynamicCall(NativeContract.StdLib.Hash, "deserialize", "280474657374".HexToBytes());	×
398	script.EmitDynamicCall(NativeContract.StdLib.Hash, "deserialize", "210164".HexToBytes());	×
399
400	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
401	engine.LoadScript(script.ToArray());	×
402
403	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
404	Assert.AreEqual(2, engine.ResultStack.Count);	×
405
406	Assert.AreEqual(engine.ResultStack.Pop<Integer>().GetInteger(), 100);	×
407	Assert.AreEqual(engine.ResultStack.Pop<ByteString>().GetString(), "test");	×
408	}	×
409
410	[TestMethod]
411	public void TestBase64Url()
NEW 412	{	×
NEW 413	var snapshotCache = TestBlockchain.GetTestSnapshotCache();	×
NEW 414	using (var script = new ScriptBuilder())	×
NEW 415	{	×
416	// Test encoding
NEW 417	script.EmitDynamicCall(NativeContract.StdLib.Hash, "base64UrlEncode", "Subject=test@example.com&Issuer=https://example.com");	×
NEW 418	script.EmitDynamicCall(NativeContract.StdLib.Hash, "base64UrlDecode", "U3ViamVjdD10ZXN0QGV4YW1wbGUuY29tJklzc3Vlcj1odHRwczovL2V4YW1wbGUuY29t");	×
419
NEW 420	using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshotCache, settings: TestBlockchain.TheNeoSystem.Settings);	×
NEW 421	engine.LoadScript(script.ToArray());	×
422
NEW 423	Assert.AreEqual(engine.Execute(), VMState.HALT);	×
NEW 424	Assert.AreEqual(2, engine.ResultStack.Count);	×
NEW 425	Assert.AreEqual("Subject=test@example.com&Issuer=https://example.com", engine.ResultStack.Pop<ByteString>());	×
NEW 426	Assert.AreEqual("U3ViamVjdD10ZXN0QGV4YW1wbGUuY29tJklzc3Vlcj1odHRwczovL2V4YW1wbGUuY29t", engine.ResultStack.Pop<ByteString>().GetString());	×
NEW 427	}	×
NEW 428	}	×
429	}
430	}

neo-project / neo / 11888209959

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous