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); }