public void SetNewBranchTest2()
{
List <Step> sequence = new List <Step>()
{
new NavigateStep(),
new GroupStep()
{
Steps = new List <Step>()
{
new GetValueStep(),
new GetValueStep()
}
}
};
ExecutionStack executionStack = new ExecutionStack();
executionStack.SetSequence(sequence);
List <Step> newBranch = ((GroupStep)sequence[1]).Steps;
FixedIterator iterator = new FixedIterator(new FixedIteration());
executionStack.SetNewBranch(newBranch, iterator);
PrivateObject m_PendingBranch = new PrivateObject(executionStack, "m_PendingBranch");
Assert.IsTrue(m_PendingBranch
.GetProperty("Steps", null)
.Equals(newBranch));
Assert.IsTrue(m_PendingBranch
.GetProperty("IterationContext", null)
.Equals(iterator));
}
public void AllSteps(int index, bool eachExecution)
{
bool isStopped = false;
ProgramState ps = repo.GetProgramState(index);
Console.WriteLine(ps.Tostring());
ExecutionStack executionStack = ps.GetExecutionStack();
while (!executionStack.IsEmpty())
{
try
{
OneStep(ps, executionStack, eachExecution);
repo.SaveLog(ps);
}
catch (CustomException exc)
{
Console.WriteLine(exc.Message);
isStopped = true;
break;
}
}
if (!eachExecution && !isStopped)
{
Console.WriteLine(ps.Tostring());
}
ps.Reload();
}
public DebugEngine()
: base() {
Log = new Log();
ExecutionStack = new ExecutionStack();
OperatorTrace = new OperatorTrace();
InitializeTimer();
}
public void Execution_Stack_Test_Add_Guid_Makes_Stack_Nonempty()
{
var SUT = new ExecutionStack();
SUT.ProcessEntry(1, Guid.NewGuid());
Assert.IsTrue(!SUT.IsStackEmpty(1));
SUT.ClearStack();
}
public ProgramState Execute(ProgramState ps)
{
ExecutionStack executionStack = ps.GetExecutionStack();
executionStack.Push(right);
executionStack.Push(left);
return(ps);
}
public static EXECUTION_RESULT?EQ_VERIFY(ref ExecutionStack stack)
{
if (EQUALS(ref stack) != null)
{
stack.Push(false);
}
return(Verify.VERIFY(ref stack));
}
public void Execution_Stack_Test_No_Access_To_Other_Thread()
{
var SUT = new ExecutionStack();
SUT.ProcessEntry(1, Guid.NewGuid());
Assert.IsTrue(SUT.IsStackEmpty(2));
SUT.ClearStack();
}
public void Execution_Stack_Test_Check_Equality_Of_Pushed_Method()
{
var SUT = new ExecutionStack();
var newGuid = Guid.NewGuid();
SUT.ProcessEntry(1, newGuid);
Assert.IsTrue(SUT.ExecutingGuid(1) == newGuid);
}
public void Execution_Stack_Test_Clear_Stack()
{
var SUT = new ExecutionStack();
SUT.ProcessEntry(1, Guid.NewGuid());
SUT.ClearStack();
Assert.IsTrue(SUT.IsStackEmpty(1));
}
public static EXECUTION_RESULT?CHECKLOCKTIME_VERIFY(ref ExecutionStack stack)
{
if (CHECKLOCKTIME(ref stack) != null)
{
stack.Push(false);
}
return(VERIFY(ref stack));
}
public ProgramState execute(ProgramState programState)
{
ExecutionStack <Statement> executionStack = programState.getExecutionStack();
executionStack.push(second);
executionStack.push(first);
return(programState);
}
public static void EVAL_SCRIPT(ref ExecutionStack stack)
{
Script lockScript = new Script(stack.Pop());
Script unlockScript = new Script(stack.Pop());
unlockScript.InsertScript(lockScript);
stack.Script.AddRange(unlockScript.Reverse().ToArray());
}
public void Execution_Stack_Test_Method_Exception_Removes_Guid()
{
var SUT = new ExecutionStack();
SUT.ProcessEntry(1, Guid.NewGuid());
SUT.ProcessException(1);
Assert.IsTrue(SUT.IsStackEmpty(1));
SUT.ClearStack();
}
public static EXECUTION_RESULT?EQUALS(ref ExecutionStack stack)
{
if (stack.Count < 2)
{
return(EXECUTION_RESULT.INVALID_STACK);
}
stack.Push(System.Linq.Enumerable.SequenceEqual(stack.Pop(), stack.Pop()));
return(null);
}
public void BreakBranchTest()
{
ExecutionStack executionStack = new ExecutionStack();
executionStack.BreakBranch();
PrivateObject m_BreakBranch = new PrivateObject(executionStack, "m_BreakBranch");
Assert.IsTrue((bool)m_BreakBranch.Target);
}
public Interpreter(int maxStack, int maxStorage, int maxFunctions, int maxInstructionDefs, int maxTwilightPoints)
{
stack = new ExecutionStack(maxStack);
storage = new int[maxStorage];
functions = new InstructionStream[maxFunctions];
instructionDefs = new InstructionStream[maxInstructionDefs > 0 ? 256 : 0];
state = new GraphicsState();
cvtState = new GraphicsState();
twilight = new Zone(new PointF[maxTwilightPoints], isTwilight: true);
}
public void SkipIterationTest()
{
ExecutionStack executionStack = new ExecutionStack();
executionStack.SkipIteration();
PrivateObject m_SkipIteration = new PrivateObject(executionStack, "m_SkipIteration");
Assert.IsTrue((bool)m_SkipIteration.Target);
}
public static EXECUTION_RESULT?DUP(ref ExecutionStack stack)
{
if (!stack.Any())
{
return(EXECUTION_RESULT.INVALID_STACK);
}
var item = stack.Pop();
stack.Push(item, item);
return(null);
}
public void SetSequenceTest()
{
List <Step> sequence = new List <Step>()
{
new NavigateStep()
};
ExecutionStack executionStack = new ExecutionStack();
executionStack.SetSequence(sequence);
Assert.IsNotNull(executionStack.CurrentBranch);
}
public void Execution_Stack_Test_Check_Equality_Of_Mult_Pushed_Methods()
{
var SUT = new ExecutionStack();
var g1 = Guid.NewGuid();
var g2 = Guid.NewGuid();
SUT.ProcessEntry(1, g1);
SUT.ProcessEntry(1, g2);
Assert.IsTrue(SUT.ExecutingGuid(1) == g2);
SUT.ProcessExit(1);
Assert.IsTrue(SUT.ExecutingGuid(1) == g1);
}
public ProgramState(ExecutionStack <Statement> executionStack,
SymbolTable <string, int> symbolTable,
FileTable <int, FileData <string, StreamReader> > fileTable,
FileDescriptorGenerator generator,
Output <string> output)
{
this.executionStack = executionStack;
this.symbolTable = symbolTable;
this.fileTable = fileTable;
this.generator = generator;
this.output = output;
}
protected override void Run(CancellationToken cancellationToken)
{
IOperation next;
OperationCollection coll;
IAtomicOperation operation;
while (ExecutionStack.Count > 0)
{
cancellationToken.ThrowIfCancellationRequested();
next = ExecutionStack.Pop();
if (next is OperationCollection)
{
coll = (OperationCollection)next;
for (int i = coll.Count - 1; i >= 0; i--)
{
if (coll[i] != null)
{
ExecutionStack.Push(coll[i]);
}
}
}
else if (next is IAtomicOperation)
{
operation = (IAtomicOperation)next;
try {
next = operation.Operator.Execute((IExecutionContext)operation, cancellationToken);
}
catch (Exception ex) {
ExecutionStack.Push(operation);
if (ex is OperationCanceledException)
{
throw ex;
}
else
{
throw new OperatorExecutionException(operation.Operator, ex);
}
}
if (next != null)
{
ExecutionStack.Push(next);
}
if (operation.Operator.Breakpoint)
{
Log.LogMessage(string.Format("Breakpoint: {0}", operation.Operator.Name != string.Empty ? operation.Operator.Name : operation.Operator.ItemName));
Pause();
}
}
}
}
public static EXECUTION_RESULT?VERIFY(ref ExecutionStack stack)
{
if (!stack.Any())
{
return(EXECUTION_RESULT.INVALID_STACK);
}
else if (!stack.PopBool())
{
return(EXECUTION_RESULT.FAILURE);
}
else
{
return(null);
}
}
public static EXECUTION_RESULT?CHECKSIG(ref ExecutionStack stack)
{
if (stack.Transaction == null)
{
return(EXECUTION_RESULT.NO_TRANSACTION_GIVEN);
}
if (stack.Count < 2)
{
return(EXECUTION_RESULT.INVALID_STACK);
}
//Verify if signature is valid
stack.Push(new CryptoRSA(stack.Pop()).Verify(stack.Transaction.Hash(), stack.Pop()));
return(null);
}
public ProgramState Execute(ProgramState ps)
{
SymbolTable symbolTable = ps.GetSymbolTable();
ExecutionStack executionStack = ps.GetExecutionStack();
int result = expression.Evaluate(symbolTable);
if (result == 0)
{
executionStack.Push(selse);
}
else
{
executionStack.Push(sthen);
}
return(ps);
}
public ProgramState execute(ProgramState programState)
{
ExecutionStack <Statement> executionStack = programState.getExecutionStack();
SymbolTable <string, int> symbolTable = programState.getSymbolTable();
if (expression.evaluate(symbolTable) != 0)
{
executionStack.push(ifBranch);
}
else if (elseBranch != null)
{
executionStack.push(elseBranch);
}
return(programState);
}
public void OneStep(ProgramState ps, ExecutionStack es, bool eachExecution)
{
try
{
IStatement statement = es.Pop();
statement.Execute(ps);
if (eachExecution)
{
Console.WriteLine(ps.Tostring());
}
}
catch (CustomException exc)
{
throw exc;
}
}
public void Execution_Stack_Test_Exit_On_Empty_Stack_Throws_Exception()
{
var SUT = new ExecutionStack();
var exceptionThrown = false;
try
{
SUT.ProcessExit(1);
}
catch (ExecutionStackEmptyException ex)
{
exceptionThrown = true;
}
Assert.IsTrue(exceptionThrown);
SUT.ClearStack();
}
protected override void Run(CancellationToken cancellationToken)
{
IOperation next;
OperationCollection coll;
IAtomicOperation operation;
while (ExecutionStack.Count > 0)
{
cancellationToken.ThrowIfCancellationRequested();
next = ExecutionStack.Pop();
if (next is OperationCollection)
{
coll = (OperationCollection)next;
for (int i = coll.Count - 1; i >= 0; i--)
{
if (coll[i] != null)
{
ExecutionStack.Push(coll[i]);
}
}
}
else if (next is IAtomicOperation)
{
operation = (IAtomicOperation)next;
try {
next = operation.Operator.Execute((IExecutionContext)operation, cancellationToken);
}
catch (Exception ex) {
ExecutionStack.Push(operation);
if (ex is OperationCanceledException)
{
throw;
}
else
{
throw new OperatorExecutionException(operation.Operator, ex);
}
}
if (next != null)
{
ExecutionStack.Push(next);
}
}
}
}
public ProgramState executeOneStep(ProgramState program)
{
if (program == null)
{
throw (new InterpreterException("error: no program to execute"));
}
ExecutionStack <Statement> executionStack = program.getExecutionStack();
if (executionStack.isEmpty())
{
throw (new InterpreterException("\nerror: execution stack is empty"));
}
else
{
Statement statement = executionStack.pop();
return(statement.execute(program));
}
}
public static EXECUTION_RESULT?CHECKLOCKTIME(ref ExecutionStack stack)
{
if (stack.Transaction == null)
{
return(EXECUTION_RESULT.NO_TRANSACTION_GIVEN);
}
if (stack.Count() < 1)
{
return(EXECUTION_RESULT.INVALID_STACK);
}
if (stack.Peek().Length != 4)
{
return(EXECUTION_RESULT.INVALID_BYTE_SIZE);
}
uint size = stack.PopUInt();
stack.Push(stack.Transaction.lockTime >= size);
return(null);
}
private IEnumerable <string> CommandProcessor(XmlNode root)
{
if (root.HasChildNodes)
{
foreach (XmlNode topLevelCommand in root.ChildNodes)
{
if (topLevelCommand.LocalName.Equals("Run", StringComparison.InvariantCultureIgnoreCase))
{
string name = "Unnamed Run";
SetupRun(topLevelCommand, ref name);
yield return(name);
}
else
{
if (topLevelCommand.NodeType != XmlNodeType.Comment)
{
var commandName = topLevelCommand.LocalName;
if (!BatchCommands.TryGetValue(commandName.ToLowerInvariant(), out Action <XmlNode> command))
{
throw new XTMFRuntimeException(this, "We are unable to find a command named '" + commandName
+ "' for batch processing. Please check your batch file!\r\n" + topLevelCommand.OuterXml);
}
var initialCount = ExecutionStack.Count;
command.Invoke(topLevelCommand);
if (initialCount < ExecutionStack.Count)
{
var current = ExecutionStack.Pop();
foreach (var run in CommandProcessor(current))
{
yield return(run);
}
}
}
}
}
}
}
