public PrgState(IMyDict <string, int> dict, IMyStack <IStatement> stack, IMyList <int> outList, FileTable <int, FileData> fileTable)
{
this.dict = dict;
this.stack = stack;
this.outList = outList;
this.fileTable = fileTable;
}
private static void PrintMyStack(IMyStack <int> myStack)
{
foreach (var item in myStack)
{
Console.WriteLine(item);
}
}
private static void Test(IMyStack <int> stack)
{
foreach (var i in Enumerable.Range(0, 9))
{
stack.Push(i);
}
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Peek());
foreach (var i in Enumerable.Repeat(2, 5))
{
stack.Push(i);
}
try
{
while (true)
{
Console.WriteLine(stack.Pop());
}
}
catch (InvalidOperationException)
{
Console.WriteLine("Stack is empty");
}
}
public void MyStack_3_Top_1_ThrowsExceptionOnEmptyStack()
{
// Arrange
IMyStack <int> stack = DSBuilder.CreateMyArrayListStack();
// Act & Assert
Assert.Throws(typeof(MyStackEmptyException), () => stack.Top());
}
public void MyStack_4_Pop_1_ThrowsExceptionOnEmptyList()
{
// Arrange
IMyStack <string> stack = DSBuilder.CreateMyStack();
// Act & Assert
Assert.Throws(typeof(MyStackEmptyException), () => stack.Pop());
}
public PrgState Execute(PrgState state)
{
IMyStack <IStmt> stk = state.ExeStack;
stk.Push(snd);
stk.Push(first);
return(state);
}
public PrgState(IMyStack <IStmt> exe, IMyDictionary <String, int> d, IMyList <int> l, IMyFileTable <int, FileData> ft, IStmt orig)
{
exeStack = exe;
symTable = d;
messages = l;
fileTable = ft;
originalPrg = orig;
exeStack.Push(orig);
}
public ProgramState(IMyStack<IMyStatement> executionStack, IMyDictionary<string, int> myDictionary, IMyList<string> output, IHeap<int, int> heap, IMyStatement originalProgram)
{
this.executionStack = executionStack;
this.myDictionary = myDictionary;
this.output = output;
this.originalProgram = originalProgram;
this.executionStack.push(originalProgram);
this.heap = heap;
this.stateId = globalStateId++;
}
public PrgState OneStep(PrgState state)
{
IMyStack <IStatement> stack = state.Stack;
if (!(stack.IsEmpty()))
{
IStatement statement = stack.Pop();
return(statement.Execute(state));
}
return(null);
}
public void MyStack_1_Constructor_1_IsEmptyReturnsTrue()
{
// Arrange
IMyStack <string> stack = DSBuilder.CreateMyStack();
bool expected = true;
// Act
bool actual = stack.IsEmpty();
// Assert
Assert.AreEqual(expected, actual);
}
public PrgState OneStep(PrgState state)
{
IMyStack <IStmt> stk = state.ExeStack;
if (stk.IsEmpty())
{
throw new Exception("The execution stack is empty");
}
IStmt crtStmt = stk.Pop();
return(crtStmt.Execute(state));
}
public void MyStack_2_Push_4_PopIsOkAfter1Push()
{
// Arrange
IMyStack <string> stack = DSBuilder.CreateMyStack();
string expected = "a";
// Act
stack.Push("a");
string actual = stack.Pop();
// Assert
Assert.AreEqual(expected, actual);
}
public void MyStack_2_Push_1_IsEmptyReturnsFalse()
{
// Arrange
IMyStack <string> stack = DSBuilder.CreateMyStack();
bool expected = false;
// Act
stack.Push("a");
bool actual = stack.IsEmpty();
// Assert
Assert.AreEqual(expected, actual);
}
public void MyStack_2_Push_4_PopIsOkAfter1Push()
{
// Arrange
IMyStack <int> stack = DSBuilder.CreateMyArrayListStack();
int expected = 1;
// Act
stack.Push(1);
int actual = stack.Pop();
// Assert
Assert.AreEqual(expected, actual);
}
public void MyStack_4_Pop_2_IsEmptyReturnsTrueAfterTopOnOneElement()
{
// Arrange
IMyStack <string> stack = DSBuilder.CreateMyStack();
bool expected = true;
// Act
stack.Push("a");
stack.Pop();
bool actual = stack.IsEmpty();
// Assert
Assert.AreEqual(expected, actual);
}
public void MyStack_3_Top_2_IsEmptyReturnsFalseAfterTopOnOneElement()
{
// Arrange
IMyStack <int> stack = DSBuilder.CreateMyArrayListStack();
bool expected = false;
// Act
stack.Push(1);
stack.Top();
bool actual = stack.IsEmpty();
// Assert
Assert.AreEqual(expected, actual);
}
public PrgState Execute(PrgState state)
{
IMyStack <IStmt> stk = state.ExeStack;
IMyDictionary <string, int> sym = state.SymTable;
int val = expr.Eval(sym);
if (val == 0)
{
stk.Push(elses);
}
else
{
stk.Push(ifs);
}
return(state);
}
public PrgState Execute(PrgState state)
{
IMyDictionary <string, int> sym = state.SymTable;
IMyStack <IStmt> stk = state.ExeStack;
int val = expr.Eval(sym);
if (sym.Exists(id))
{
sym.Update(id, val);
}
else
{
sym.Add(id, val);
}
return(state);
}
public void setExecutionStack(IMyStack<IMyStatement> mExecutionStack)
{
this.executionStack = mExecutionStack;
}
public void createProgram(IMyStack<IMyStatement> mExecutionStack, IMyDictionary<String, int> myDictionary, IMyList<String> mOutput, IHeap<int, int> heap, IMyStatement mInitialProgram)
{
programStateList.Add(new ProgramState(mExecutionStack, myDictionary, mOutput, heap, mInitialProgram));
}
