private void TestToParameter2VMBoolean()
{
StackItem item = new VM.Types.Boolean(true);
ContractParameter parameter = VM.Helper.ToParameter(item);
Assert.AreEqual(ContractParameterType.Boolean, parameter.Type);
Assert.AreEqual(true, parameter.Value);
}
public void TestOnPersistWithArgs()
{
var snapshot = Blockchain.Singleton.GetSnapshot();
ApplicationEngine engine1 = new ApplicationEngine(TriggerType.Application, null, snapshot, 0);
VMArray args = new VMArray();
VM.Types.Boolean result1 = new VM.Types.Boolean(false);
testNativeContract.TestOnPersist(engine1, args).Should().Be(result1);
ApplicationEngine engine2 = new ApplicationEngine(TriggerType.System, null, snapshot, 0);
VM.Types.Boolean result2 = new VM.Types.Boolean(true);
testNativeContract.TestOnPersist(engine2, args).Should().Be(result2);
}
public void TestNextAndValue()
{
StackItem stackItem = new VM.Types.Boolean(true);
List <StackItem> list = new List <StackItem>();
list.Add(stackItem);
ArrayWrapper wrapper = new ArrayWrapper(list);
IteratorKeysWrapper iteratorKeysWrapper = new IteratorKeysWrapper(wrapper);
Action action = () => iteratorKeysWrapper.Next();
action.Should().NotThrow <Exception>();
Assert.AreEqual(new VM.Types.Integer(0), iteratorKeysWrapper.Value());
}
public void TestOnPersistWithArgs()
{
ApplicationEngine engine1 = new ApplicationEngine(TriggerType.Application, null, Store.GetSnapshot(), 0);
TestNativeContract testNativeContract = new TestNativeContract();
VMArray args = new VMArray();
VM.Types.Boolean result1 = new VM.Types.Boolean(false);
testNativeContract.TestOnPersist(engine1, args).Should().Be(result1);
ApplicationEngine engine2 = new ApplicationEngine(TriggerType.System, null, Store.GetSnapshot(), 0);
VM.Types.Boolean result2 = new VM.Types.Boolean(true);
testNativeContract.TestOnPersist(engine2, args).Should().Be(result2);
}
public void TestDeserializeStackItem()
{
StackItem stackItem1 = new ByteArray(new byte[5]);
byte[] byteArray1 = BinarySerializer.Serialize(stackItem1, MaxItemSize);
StackItem result1 = BinarySerializer.Deserialize(byteArray1, 2048, (uint)byteArray1.Length);
Assert.AreEqual(stackItem1, result1);
StackItem stackItem2 = new VM.Types.Boolean(true);
byte[] byteArray2 = BinarySerializer.Serialize(stackItem2, MaxItemSize);
StackItem result2 = BinarySerializer.Deserialize(byteArray2, 2048, (uint)byteArray2.Length);
Assert.AreEqual(stackItem2, result2);
StackItem stackItem3 = new Integer(1);
byte[] byteArray3 = BinarySerializer.Serialize(stackItem3, MaxItemSize);
StackItem result3 = BinarySerializer.Deserialize(byteArray3, 2048, (uint)byteArray3.Length);
Assert.AreEqual(stackItem3, result3);
byte[] byteArray4 = BinarySerializer.Serialize(1, MaxItemSize);
byteArray4[0] = 0x40;
Action action4 = () => BinarySerializer.Deserialize(byteArray4, 2048, (uint)byteArray4.Length);
action4.Should().Throw<FormatException>();
List<StackItem> list5 = new List<StackItem> { 1 };
StackItem stackItem52 = new VM.Types.Array(list5);
byte[] byteArray5 = BinarySerializer.Serialize(stackItem52, MaxItemSize);
StackItem result5 = BinarySerializer.Deserialize(byteArray5, 2048, (uint)byteArray5.Length);
Assert.AreEqual(((VM.Types.Array)stackItem52).Count, ((VM.Types.Array)result5).Count);
Assert.AreEqual(((VM.Types.Array)stackItem52).GetEnumerator().Current, ((VM.Types.Array)result5).GetEnumerator().Current);
List<StackItem> list6 = new List<StackItem> { 1 };
StackItem stackItem62 = new Struct(list6);
byte[] byteArray6 = BinarySerializer.Serialize(stackItem62, MaxItemSize);
StackItem result6 = BinarySerializer.Deserialize(byteArray6, 2048, (uint)byteArray6.Length);
Assert.AreEqual(((Struct)stackItem62).Count, ((Struct)result6).Count);
Assert.AreEqual(((Struct)stackItem62).GetEnumerator().Current, ((Struct)result6).GetEnumerator().Current);
StackItem stackItem72 = new Map { [2] = 1 };
byte[] byteArray7 = BinarySerializer.Serialize(stackItem72, MaxItemSize);
StackItem result7 = BinarySerializer.Deserialize(byteArray7, 2048, (uint)byteArray7.Length);
Assert.AreEqual(((Map)stackItem72).Count, ((Map)result7).Count);
CollectionAssert.AreEqual(((Map)stackItem72).Keys.ToArray(), ((Map)result7).Keys.ToArray());
CollectionAssert.AreEqual(((Map)stackItem72).Values.ToArray(), ((Map)result7).Values.ToArray());
}
public void VMTypes(
VM.Types.Boolean p1, VM.Types.Integer p2, VM.Types.ByteString p3, VM.Types.Buffer p4,
VM.Types.Array p5, VM.Types.Struct p6, VM.Types.Map p7, VM.Types.StackItem p8
)
{
}
public void TestDeserializeStackItem()
{
StackItem stackItem1 = new ByteArray(new byte[5]);
byte[] byteArray1 = StackItemSerializer.Serialize(stackItem1);
StackItem result1 = StackItemSerializer.Deserialize(byteArray1, 1, (uint)byteArray1.Length);
Assert.AreEqual(stackItem1, result1);
StackItem stackItem2 = new VM.Types.Boolean(true);
byte[] byteArray2 = StackItemSerializer.Serialize(stackItem2);
StackItem result2 = StackItemSerializer.Deserialize(byteArray2, 1, (uint)byteArray2.Length);
Assert.AreEqual(stackItem2, result2);
StackItem stackItem3 = new Integer(1);
byte[] byteArray3 = StackItemSerializer.Serialize(stackItem3);
StackItem result3 = StackItemSerializer.Deserialize(byteArray3, 1, (uint)byteArray3.Length);
Assert.AreEqual(stackItem3, result3);
byte[] byteArray4 = StackItemSerializer.Serialize(1);
byteArray4[0] = 0x40;
Action action4 = () => StackItemSerializer.Deserialize(byteArray4, 1, (uint)byteArray4.Length);
action4.Should().Throw <FormatException>();
List <StackItem> list5 = new List <StackItem> {
1
};
StackItem stackItem52 = new VM.Types.Array(list5);
byte[] byteArray5 = StackItemSerializer.Serialize(stackItem52);
StackItem result5 = StackItemSerializer.Deserialize(byteArray5, 1, (uint)byteArray5.Length);
Assert.AreEqual(((VM.Types.Array)stackItem52).Count, ((VM.Types.Array)result5).Count);
Assert.AreEqual(((VM.Types.Array)stackItem52).GetEnumerator().Current, ((VM.Types.Array)result5).GetEnumerator().Current);
List <StackItem> list6 = new List <StackItem> {
1
};
StackItem stackItem62 = new Struct(list6);
byte[] byteArray6 = StackItemSerializer.Serialize(stackItem62);
StackItem result6 = StackItemSerializer.Deserialize(byteArray6, 1, (uint)byteArray6.Length);
Assert.AreEqual(((Struct)stackItem62).Count, ((Struct)result6).Count);
Assert.AreEqual(((Struct)stackItem62).GetEnumerator().Current, ((Struct)result6).GetEnumerator().Current);
Dictionary <PrimitiveType, StackItem> list7 = new Dictionary <PrimitiveType, StackItem> {
[2] = 1
};
StackItem stackItem72 = new Map(list7);
byte[] byteArray7 = StackItemSerializer.Serialize(stackItem72);
StackItem result7 = StackItemSerializer.Deserialize(byteArray7, 1, (uint)byteArray7.Length);
Assert.AreEqual(((Map)stackItem72).Count, ((Map)result7).Count);
Assert.AreEqual(((Map)stackItem72).Keys.GetEnumerator().Current, ((Map)result7).Keys.GetEnumerator().Current);
Assert.AreEqual(((Map)stackItem72).Values.GetEnumerator().Current, ((Map)result7).Values.GetEnumerator().Current);
}
public void TestDeserializeStackItem()
{
StackItem stackItem1 = new ByteArray(new byte[5]);
byte[] byteArray1 = Neo.SmartContract.Helper.Serialize(stackItem1);
StackItem result1 = Neo.SmartContract.Helper.DeserializeStackItem(byteArray1, 1, (uint)byteArray1.Length);
Assert.AreEqual(stackItem1, result1);
StackItem stackItem2 = new VM.Types.Boolean(true);
byte[] byteArray2 = Neo.SmartContract.Helper.Serialize(stackItem2);
StackItem result2 = Neo.SmartContract.Helper.DeserializeStackItem(byteArray2, 1, (uint)byteArray2.Length);
Assert.AreEqual(stackItem2, result2);
StackItem stackItem3 = new VM.Types.Integer(1);
byte[] byteArray3 = Neo.SmartContract.Helper.Serialize(stackItem3);
StackItem result3 = Neo.SmartContract.Helper.DeserializeStackItem(byteArray3, 1, (uint)byteArray3.Length);
Assert.AreEqual(stackItem3, result3);
StackItem stackItem4 = new VM.Types.Integer(1);
byte[] byteArray4 = Neo.SmartContract.Helper.Serialize(stackItem4);
byteArray4[0] = 0x40;
Action action4 = () => Neo.SmartContract.Helper.DeserializeStackItem(byteArray4, 1, (uint)byteArray4.Length);
action4.Should().Throw <FormatException>();
StackItem stackItem51 = new VM.Types.Integer(1);
List <StackItem> list5 = new List <StackItem>();
list5.Add(stackItem51);
StackItem stackItem52 = new VM.Types.Array(list5);
byte[] byteArray5 = Neo.SmartContract.Helper.Serialize(stackItem52);
StackItem result5 = Neo.SmartContract.Helper.DeserializeStackItem(byteArray5, 1, (uint)byteArray5.Length);
Assert.AreEqual(((VM.Types.Array)stackItem52).Count, ((VM.Types.Array)result5).Count);
Assert.AreEqual(((VM.Types.Array)stackItem52).GetEnumerator().Current, ((VM.Types.Array)result5).GetEnumerator().Current);
StackItem stackItem61 = new VM.Types.Integer(1);
List <StackItem> list6 = new List <StackItem>();
list6.Add(stackItem61);
StackItem stackItem62 = new VM.Types.Struct(list6);
byte[] byteArray6 = Neo.SmartContract.Helper.Serialize(stackItem62);
StackItem result6 = Neo.SmartContract.Helper.DeserializeStackItem(byteArray6, 1, (uint)byteArray6.Length);
Assert.AreEqual(((VM.Types.Struct)stackItem62).Count, ((VM.Types.Struct)result6).Count);
Assert.AreEqual(((VM.Types.Struct)stackItem62).GetEnumerator().Current, ((VM.Types.Struct)result6).GetEnumerator().Current);
StackItem stackItem71 = new VM.Types.Integer(1);
Dictionary <PrimitiveType, StackItem> list7 = new Dictionary <PrimitiveType, StackItem>();
list7.Add(new VM.Types.Integer(2), stackItem71);
StackItem stackItem72 = new VM.Types.Map(list7);
byte[] byteArray7 = Neo.SmartContract.Helper.Serialize(stackItem72);
StackItem result7 = Neo.SmartContract.Helper.DeserializeStackItem(byteArray7, 1, (uint)byteArray7.Length);
Assert.AreEqual(((VM.Types.Map)stackItem72).Count, ((VM.Types.Map)result7).Count);
Assert.AreEqual(((VM.Types.Map)stackItem72).Keys.GetEnumerator().Current, ((VM.Types.Map)result7).Keys.GetEnumerator().Current);
Assert.AreEqual(((VM.Types.Map)stackItem72).Values.GetEnumerator().Current, ((VM.Types.Map)result7).Values.GetEnumerator().Current);
}
public void TestSerialize()
{
StackItem stackItem1 = new ByteArray(new byte[5]);
byte[] result1 = Neo.SmartContract.Helper.Serialize(stackItem1);
byte[] expectedArray1 = new byte[] {
0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00
};
Assert.AreEqual(Encoding.Default.GetString(expectedArray1), Encoding.Default.GetString(result1));
StackItem stackItem2 = new VM.Types.Boolean(true);
byte[] result2 = Neo.SmartContract.Helper.Serialize(stackItem2);
byte[] expectedArray2 = new byte[] {
0x01, 0x01
};
Assert.AreEqual(Encoding.Default.GetString(expectedArray2), Encoding.Default.GetString(result2));
StackItem stackItem3 = new VM.Types.Integer(1);
byte[] result3 = Neo.SmartContract.Helper.Serialize(stackItem3);
byte[] expectedArray3 = new byte[] {
0x02, 0x01, 0x01
};
Assert.AreEqual(Encoding.Default.GetString(expectedArray3), Encoding.Default.GetString(result3));
StackItem stackItem4 = new InteropInterface <object>(new object());
Action action4 = () => Neo.SmartContract.Helper.Serialize(stackItem4);
action4.Should().Throw <NotSupportedException>();
StackItem stackItem5 = new VM.Types.Integer(1);
byte[] result5 = Neo.SmartContract.Helper.Serialize(stackItem5);
byte[] expectedArray5 = new byte[] {
0x02, 0x01, 0x01
};
Assert.AreEqual(Encoding.Default.GetString(expectedArray5), Encoding.Default.GetString(result5));
StackItem stackItem61 = new VM.Types.Integer(1);
List <StackItem> list6 = new List <StackItem>
{
stackItem61
};
StackItem stackItem62 = new VM.Types.Array(list6);
byte[] result6 = Neo.SmartContract.Helper.Serialize(stackItem62);
byte[] expectedArray6 = new byte[] {
0x80, 0x01, 0x02, 0x01, 0x01
};
Assert.AreEqual(Encoding.Default.GetString(expectedArray6), Encoding.Default.GetString(result6));
StackItem stackItem71 = new VM.Types.Integer(1);
List <StackItem> list7 = new List <StackItem>
{
stackItem71
};
StackItem stackItem72 = new VM.Types.Struct(list7);
byte[] result7 = Neo.SmartContract.Helper.Serialize(stackItem72);
byte[] expectedArray7 = new byte[] {
0x81, 0x01, 0x02, 0x01, 0x01
};
Assert.AreEqual(Encoding.Default.GetString(expectedArray7), Encoding.Default.GetString(result7));
StackItem stackItem81 = new VM.Types.Integer(1);
Dictionary <PrimitiveType, StackItem> list8 = new Dictionary <PrimitiveType, StackItem>
{
{ new VM.Types.Integer(2), stackItem81 }
};
StackItem stackItem82 = new VM.Types.Map(list8);
byte[] result8 = Neo.SmartContract.Helper.Serialize(stackItem82);
byte[] expectedArray8 = new byte[] {
0x82, 0x01, 0x02, 0x01, 0x02, 0x02, 0x01, 0x01
};
Assert.AreEqual(Encoding.Default.GetString(expectedArray8), Encoding.Default.GetString(result8));
Integer stackItem9 = new VM.Types.Integer(1);
Map stackItem91 = new VM.Types.Map();
stackItem91.Add(stackItem9, stackItem91);
Action action9 = () => Neo.SmartContract.Helper.Serialize(stackItem91);
action9.Should().Throw <NotSupportedException>();
VM.Types.Array stackItem10 = new VM.Types.Array();
stackItem10.Add(stackItem10);
Action action10 = () => Neo.SmartContract.Helper.Serialize(stackItem10);
action10.Should().Throw <NotSupportedException>();
}
