public void MAXOpTest(byte[] toPop1, byte[] toPop2, byte[] toPush)
{
MockOpData data = new MockOpData(FuncCallName.Pop, FuncCallName.Pop, FuncCallName.Push)
{
_itemCount = 2,
popData = new byte[][] { toPop1, toPop2 },
pushData = new byte[][] { toPush },
};
OpTestCaseHelper.RunTest <MAXOp>(data, OP.MAX);
}
public void RunTest()
{
MockOpData data = new MockOpData(FuncCallName.PopCount, FuncCallName.PushMulti)
{
_itemCount = 2,
popCountData = new byte[][][] { new byte[][] { OpTestCaseHelper.b1, OpTestCaseHelper.b2 } },
pushMultiData = new byte[][][] { new byte[][] { OpTestCaseHelper.b2, OpTestCaseHelper.b1 } },
};
OpTestCaseHelper.RunTest <SWAPOp>(data, OP.SWAP);
}
public void Run_NoDuplicateTest()
{
MockOpData data = new MockOpData(FuncCallName.Peek)
{
_itemCount = 1,
_altItemCount = 0,
peekData = new byte[][] { OpTestCaseHelper.num0 }, // num0 is zero so no duplication occurs
};
OpTestCaseHelper.RunTest <IfDupOp>(data, OP.IfDup);
}
public void WITHINOpTest(byte[] toPop1, byte[] toPop2, byte[] toPop3, bool expBool)
{
MockOpData data = new MockOpData(FuncCallName.PopCount, FuncCallName.PushBool)
{
_itemCount = 3,
popCountData = new byte[][][] { new byte[][] { toPop1, toPop2, toPop3 } },
pushBool = expBool
};
OpTestCaseHelper.RunTest <WITHINOp>(data, OP.WITHIN);
}
public void RunTest()
{
MockOpData data = new MockOpData(FuncCallName.AltPop, FuncCallName.Push)
{
_altItemCount = 1,
altPopData = new byte[][] { OpTestCaseHelper.b1 },
pushData = new byte[][] { OpTestCaseHelper.b1 },
};
OpTestCaseHelper.RunTest <FromAltStackOp>(data, OP.FromAltStack);
}
public void RunTest()
{
MockOpData data = new MockOpData(FuncCallName.Pop, FuncCallName.AltPush)
{
_itemCount = 1,
popData = new byte[][] { OpTestCaseHelper.b1 },
altPushData = new byte[][] { OpTestCaseHelper.b1 },
};
OpTestCaseHelper.RunTest <ToAltStackOp>(data, OP.ToAltStack);
}
public void Run_ItemCountOverflowTest()
{
MockOpData data = new MockOpData(FuncCallName.Push)
{
_itemCount = 1001,
_altItemCount = 1,
pushData = new byte[][] { new byte[] { 233, 3 } },
};
OpTestCaseHelper.RunFailTest <DEPTHOp>(data, Err.OpStackItemOverflow);
}
public void GreaterThanOrEqualOpTest(byte[] toPop1, byte[] toPop2, bool expBool)
{
MockOpData data = new MockOpData(FuncCallName.Pop, FuncCallName.Pop, FuncCallName.PushBool)
{
_itemCount = 2,
popData = new byte[][] { toPop1, toPop2 },
pushBool = expBool
};
OpTestCaseHelper.RunTest <GreaterThanOrEqualOp>(data, OP.GreaterThanOrEqual);
}
public void NEGATEOpTest(byte[] toPop, byte[] toPush)
{
MockOpData data = new MockOpData(FuncCallName.Pop, FuncCallName.Push)
{
_itemCount = 1,
popData = new byte[][] { toPop },
pushData = new byte[][] { toPush },
};
OpTestCaseHelper.RunTest <NEGATEOp>(data, OP.NEGATE);
}
public void LessThanOpTest(byte[] toPop1, byte[] toPop2, bool expBool)
{
MockOpData data = new MockOpData(FuncCallName.Pop, FuncCallName.Pop, FuncCallName.PushBool)
{
_itemCount = 2,
popData = new byte[][] { toPop1, toPop2 },
pushBool = expBool,
};
OpTestCaseHelper.RunTest <LessThanOp>(data, OP.LessThan);
}
public void SUB1OpTest()
{
MockOpData data = new MockOpData(FuncCallName.Pop, FuncCallName.Push)
{
_itemCount = 1,
popData = new byte[][] { OpTestCaseHelper.num1 },
pushData = new byte[][] { OpTestCaseHelper.num0 },
};
OpTestCaseHelper.RunTest <SUB1Op>(data, OP.SUB1);
}
public void NotEqual0OpTest(byte[] toPop, bool expBool)
{
MockOpData data = new MockOpData(FuncCallName.Pop, FuncCallName.PushBool)
{
_itemCount = 1,
popData = new byte[][] { toPop },
pushBool = expBool
};
OpTestCaseHelper.RunTest <NotEqual0Op>(data, OP.NotEqual0);
}
public void Run_BigDataTest()
{
MockOpData data = new MockOpData(FuncCallName.Push)
{
_itemCount = 130,
_altItemCount = 0,
pushData = new byte[][] { new byte[] { 130, 0 } },
};
OpTestCaseHelper.RunTest <DEPTHOp>(data, OP.DEPTH);
}
public void WITHINOp_FailTest(FuncCallName[] calls, int count, byte[][][] pop, byte[][] push, string expErr)
{
MockOpData data = new MockOpData(calls)
{
_itemCount = count,
popCountData = pop,
pushData = push,
};
OpTestCaseHelper.RunFailTest <WITHINOp>(data, expErr);
}
public void Run_ItemCountOverflowTest()
{
MockOpData data = new MockOpData(FuncCallName.PeekCount, FuncCallName.PushMulti)
{
_itemCount = 1000,
_altItemCount = 1,
peekCountData = new byte[][][] { new byte[][] { OpTestCaseHelper.b1, OpTestCaseHelper.b2, OpTestCaseHelper.b3 } },
pushMultiData = new byte[][][] { new byte[][] { OpTestCaseHelper.b1, OpTestCaseHelper.b2, OpTestCaseHelper.b3 } },
};
OpTestCaseHelper.RunFailTest <DUP3Op>(data, Err.OpStackItemOverflow);
}
public void RunTest()
{
MockOpData data = new MockOpData(FuncCallName.Peek, FuncCallName.Push)
{
_itemCount = 1,
_altItemCount = 0,
peekData = new byte[][] { OpTestCaseHelper.b1 },
pushData = new byte[][] { OpTestCaseHelper.b1 },
};
OpTestCaseHelper.RunTest <DUPOp>(data, OP.DUP);
}
public void RunTest()
{
MockOpData data = new MockOpData(FuncCallName.PopIndex)
{
_itemCount = 2,
popIndexData = new Dictionary <int, byte[]> {
{ 1, OpTestCaseHelper.b1 }
}
};
OpTestCaseHelper.RunTest <NIPOp>(data, OP.NIP);
}
public void Run_DuplicateTest()
{
MockOpData data = new MockOpData(FuncCallName.Peek, FuncCallName.Push)
{
_itemCount = 1,
_altItemCount = 0,
peekData = new byte[][] { OpTestCaseHelper.b1 }, // b1 is not zero so it should be duplicated
pushData = new byte[][] { OpTestCaseHelper.b1 },
};
OpTestCaseHelper.RunTest <IfDupOp>(data, OP.IfDup);
}
public void Run_Error_HugeNumTest()
{
MockOpData data = new MockOpData(FuncCallName.Pop)
{
_itemCount = 2,
popData = new byte[][] { OpTestCaseHelper.b1, new byte[5] {
1, 1, 1, 1, 1
} },
};
OpTestCaseHelper.RunFailTest <PICKOp>(data, "'n' is too big.");
}
public void Run_ItemCountOverflowTest()
{
MockOpData data = new MockOpData(FuncCallName.Peek, FuncCallName.Push)
{
_itemCount = 999,
_altItemCount = 2,
peekData = new byte[][] { OpTestCaseHelper.b1 },
pushData = new byte[][] { OpTestCaseHelper.b1 },
};
OpTestCaseHelper.RunFailTest <DUPOp>(data, Err.OpStackItemOverflow);
}
public void RunTest()
{
MockOpData data = new MockOpData(FuncCallName.PeekCount, FuncCallName.PushMulti)
{
_itemCount = 3,
_altItemCount = 0,
peekCountData = new byte[][][] { new byte[][] { OpTestCaseHelper.b1, OpTestCaseHelper.b2, OpTestCaseHelper.b3 } },
pushMultiData = new byte[][][] { new byte[][] { OpTestCaseHelper.b1, OpTestCaseHelper.b2, OpTestCaseHelper.b3 } },
};
OpTestCaseHelper.RunTest <DUP3Op>(data, OP.DUP3);
}
public void Run_ItemCountOverflowTest()
{
MockOpData data = new MockOpData(FuncCallName.Peek, FuncCallName.Push)
{
_itemCount = 1001,
_altItemCount = 0,
peekData = new byte[][] { OpTestCaseHelper.b1 }, // b1 is not zero so it should be duplicated
pushData = new byte[][] { OpTestCaseHelper.b1 },
};
OpTestCaseHelper.RunFailTest <IfDupOp>(data, Err.OpStackItemOverflow);
}
public void TrySetValue_FailTest()
{
MockOpData data = new MockOpData(FuncCallName.Pop)
{
_itemCount = 0,
};
MockSingleBase op = new MockSingleBase(0, false);
bool b = op.Run(data, out string error);
Assert.False(b);
Assert.Equal(Err.OpNotEnoughItems, error);
}
public void Run_FailTest()
{
IFOp op = new IFOp(null, null);
MockOpData data = new MockOpData()
{
_itemCount = 0
};
bool b = op.Run(data, out string error);
Assert.False(b);
Assert.Equal(Err.OpNotEnoughItems, error);
}
public void TrySetValueTest(int first, int second, byte[] ba1, byte[] ba2)
{
MockDoubleBase op = new MockDoubleBase(first, second, true);
MockOpData data = new MockOpData(FuncCallName.Pop, FuncCallName.Pop)
{
_itemCount = 2,
popData = new byte[][] { ba1, ba2 },
};
bool b = op.Run(data, out string error);
Assert.True(b, error);
Assert.Null(error);
}
public void TrySetValueTest(int i, byte[] ba)
{
MockSingleBase op = new MockSingleBase(i, true);
MockOpData data = new MockOpData(FuncCallName.Pop)
{
_itemCount = 1,
popData = new byte[][] { ba },
};
bool b = op.Run(data, out string error);
Assert.True(b, error);
Assert.Null(error);
}
public void RunTest2()
{
MockOpData data = new MockOpData(FuncCallName.Pop, FuncCallName.PopIndex, FuncCallName.Push)
{
_itemCount = 4,
popData = new byte[][] { OpTestCaseHelper.b1, OpTestCaseHelper.b2, OpTestCaseHelper.b3, OpTestCaseHelper.num1 },
popIndexData = new Dictionary <int, byte[]> {
{ 1, OpTestCaseHelper.b2 }
},
pushData = new byte[][] { OpTestCaseHelper.b2 },
};
OpTestCaseHelper.RunTest <ROLLOp>(data, OP.ROLL);
}
public void RunTest()
{
MockOpData data = new MockOpData(FuncCallName.PeekIndex, FuncCallName.Push)
{
_itemCount = 2,
_altItemCount = 0,
peekIndexData = new Dictionary <int, byte[]> {
{ 1, OpTestCaseHelper.b1 }
},
pushData = new byte[][] { OpTestCaseHelper.b1 },
};
OpTestCaseHelper.RunTest <OVEROp>(data, OP.OVER);
}
public void Run_ItemCountOverflowTest()
{
MockOpData data = new MockOpData(FuncCallName.PeekIndex, FuncCallName.Push)
{
_itemCount = 1001,
_altItemCount = 2,
peekIndexData = new Dictionary <int, byte[]> {
{ 1, OpTestCaseHelper.b1 }
},
pushData = new byte[][] { OpTestCaseHelper.b1 },
};
OpTestCaseHelper.RunFailTest <OVEROp>(data, Err.OpStackItemOverflow);
}
public void RunTest3()
{
MockOpData data = new MockOpData(FuncCallName.Pop, FuncCallName.PeekIndex, FuncCallName.Push)
{
_itemCount = 4,
popData = new byte[][] { OpTestCaseHelper.b1, OpTestCaseHelper.b2, OpTestCaseHelper.b3, OpTestCaseHelper.num2 },
peekIndexData = new Dictionary <int, byte[]> {
{ 2, OpTestCaseHelper.b1 }
},
pushData = new byte[][] { OpTestCaseHelper.b1 },
};
OpTestCaseHelper.RunTest <PICKOp>(data, OP.PICK);
}
