public void TestCopyTo()
{
var stack = CreateOrderedStack(3);
var copy = new RandomAccessStack <int>();
stack.CopyTo(copy, 0);
Assert.AreEqual(3, stack.Count);
Assert.AreEqual(0, copy.Count);
CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, ((IEnumerable <int>)stack).Select(u => u).ToArray());
stack.CopyTo(copy, -1);
Assert.AreEqual(3, stack.Count);
Assert.AreEqual(3, copy.Count);
CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, ((IEnumerable <int>)stack).Select(u => u).ToArray());
// Test IEnumerable
var enumerable = (IEnumerable)copy;
var enumerator = enumerable.GetEnumerator();
CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, GetEnumerable(enumerator).Cast <int>().Select(u => u).ToArray());
copy.CopyTo(stack, 2);
Assert.AreEqual(5, stack.Count);
Assert.AreEqual(3, copy.Count);
CollectionAssert.AreEqual(new int[] { 1, 2, 3, 2, 3 }, stack.Select(u => u).ToArray());
CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, copy.Select(u => u).ToArray());
}
/// <summary>
/// Assert result stack
/// </summary>
/// <param name="stack">Stack</param>
/// <param name="result">Result</param>
/// <param name="message">Message</param>
private void AssertResult(RandomAccessStack <StackItem> stack, VMUTStackItem[] result, string message)
{
AssertAreEqual(stack.Count, result == null ? 0 : result.Length, message + "Stack is different");
for (int x = 0, max = stack.Count; x < max; x++)
{
AssertAreEqual(ItemToJson(stack.Peek(x)).ToString(Formatting.None), PrepareJsonItem(result[x]).ToString(Formatting.None), message + "Stack item is different");
}
}
public static bool TryPopAdapter <T>(this RandomAccessStack <StackItem> stack, [NotNullWhen(true)] out T?adapter)
where T : ModelAdapters.AdapterBase
{
if (stack.Pop() is T _adapter)
{
adapter = _adapter;
return(true);
}
adapter = null;
return(false);
}
public static long GetPrice(uint hash, RandomAccessStack <StackItem> stack)
{
if (prices.TryGetValue(hash, out long price))
{
return(price);
}
else
{
return(priceCalculators[hash](stack));
}
}
private string[] ResultStackToStringArray(RandomAccessStack <StackItem> stack)
{
int stackSize = stack.Count;
List <string> stringList = new List <string>();
for (int i = 0; i < stackSize; i++)
{
list.Add(stack.Pop().ToString());
}
// Index 0 is the "top" of the stack
return(stringList.ToArray());
}
private bool DumpStack(RandomAccessStack <StackItem> stack)
{
if (!DebuggerActive)
{
return(false);
}
for (var i = stack.GetEnumerator(); i.MoveNext();)
{
StackItem item = i.Current;
Console.WriteLine(ItemToJson(item));
}
return(true);
}
/// <summary>
/// Assert invocation stack
/// </summary>
/// <param name="stack">Stack</param>
/// <param name="result">Result</param>
/// <param name="message">Message</param>
private void AssertResult(RandomAccessStack <ExecutionContext> stack, VMUTExecutionContextState[] result, string message)
{
AssertAreEqual(stack.Count, result == null ? 0 : result.Length, message + "Stack is different");
for (int x = 0, max = stack.Count; x < max; x++)
{
var context = stack.Peek(x);
AssertAreEqual(context.ScriptHash.ToHexString().ToUpper(), result[x].ScriptHash.ToHexString().ToUpper(), message + "Script hash is different");
AssertAreEqual(context.NextInstruction, result[x].NextInstruction, message + "Next instruction is different");
AssertAreEqual(context.InstructionPointer, result[x].InstructionPointer, message + "Instruction pointer is different");
AssertResult(context.EvaluationStack, result[x].EvaluationStack, message + " [EvaluationStack]");
AssertResult(context.AltStack, result[x].AltStack, message + " [AltStack]");
}
}
public static bool TryPopInterface <T>(this RandomAccessStack <StackItem> stack, [NotNullWhen(true)] out T?value)
where T : class
{
if (stack.Pop() is InteropInterface @interface)
{
var t = @interface.GetInterface <T>();
if (t != null)
{
value = t;
return(true);
}
}
value = default;
return(false);
}
RandomAccessStack <int> CreateOrderedStack(int count)
{
var check = new int[count];
var stack = new RandomAccessStack <int>();
for (int x = 1; x <= count; x++)
{
stack.Push(x);
check[x - 1] = x;
}
Assert.AreEqual(count, stack.Count);
CollectionAssert.AreEqual(check, stack.Select(u => u).ToArray());
return(stack);
}
/// <summary>
/// Assert invocation stack
/// </summary>
/// <param name="stack">Stack</param>
/// <param name="result">Result</param>
/// <param name="message">Message</param>
private void AssertResult(RandomAccessStack <ExecutionContext> stack, VMUTExecutionContextState[] result, string message)
{
AssertAreEqual(stack.Count, result == null ? 0 : result.Length, message + "Stack is different");
for (int x = 0, max = stack.Count; x < max; x++)
{
var context = stack.Peek(x);
var opcode = context.InstructionPointer >= context.Script.Length ? OpCode.RET : context.Script[context.InstructionPointer];
AssertAreEqual(opcode, result[x].NextInstruction, message + "Next instruction is different");
AssertAreEqual(context.InstructionPointer, result[x].InstructionPointer, message + "Instruction pointer is different");
AssertResult(context.EvaluationStack, result[x].EvaluationStack, message + " [EvaluationStack]");
AssertResult(context.AltStack, result[x].AltStack, message + " [AltStack]");
}
}
public void TestInsertPeek()
{
var stack = new RandomAccessStack <int>();
stack.Insert(0, 3);
stack.Insert(1, 1);
stack.Insert(1, 2);
Assert.ThrowsException <InvalidOperationException>(() => stack.Insert(4, 2));
Assert.AreEqual(3, stack.Count);
CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, stack.Select(u => u).ToArray());
Assert.AreEqual(3, stack.Peek(0));
Assert.AreEqual(2, stack.Peek(1));
Assert.AreEqual(1, stack.Peek(-1));
}
private static long GetCheckMultiSigPrice(RandomAccessStack <StackItem> stack)
{
if (stack.Count == 0)
{
return(0);
}
var item = stack.Peek();
int n;
if (item is VMArray array)
{
n = array.Count;
}
else
{
n = (int)item.GetBigInteger();
}
if (n < 1)
{
return(0);
}
return(GetPrice(Neo_Crypto_CheckSig, stack) * n);
}
private static long GetDeploymentPrice(RandomAccessStack <StackItem> stack)
{
int size = stack.Peek(0).GetByteLength() + stack.Peek(1).GetByteLength();
return(GasPerByte * size);
}
private static long GetStoragePrice(RandomAccessStack <StackItem> stack)
{
return((stack.Peek(1).GetByteLength() + stack.Peek(2).GetByteLength()) * GasPerByte);
}
public ExecutionStackContainer(IVariableContainerSession session, RandomAccessStack <StackItem> execStack, string stackName)
{
this.session = session;
this.execStack = execStack;
this.stackName = stackName;
}
public StackExecutionContextWrapper(RandomAccessStack <ExecutionContext> invocationStack)
{
_stack = invocationStack;
}
public long GetPrice(RandomAccessStack <StackItem> stack)
{
return(PriceCalculator is null ? Price : PriceCalculator(stack));
}
public StackWrapper(RandomAccessStack <StackItem> stack)
{
_stack = stack;
}
internal long GetPrice(RandomAccessStack <StackItem> stack)
{
return(methods.TryGetValue(stack.Peek().GetString(), out ContractMethodMetadata method) ? method.Price : 0);
}
