public void CommentParingTests_EmptyLine()
{
var sourceCode = string.Empty;
var parser = new Z80LineParser();
AssertExtension.IsCorrectCommandType <BlankLine>(parser.ParseLine(sourceCode));
}
public void CommentParingTests_JustLabel()
{
var sourceCode = "routine4: ";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <BlankLine>(parser.ParseLine(sourceCode));
Assert.AreEqual("routine4", actualCommand.Label);
}
public void CommentParingTests_SpaceBeforeSemicolons()
{
var sourceCode = " ;This is a comment";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <Comment>(parser.ParseLine(sourceCode));
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual("This is a comment", actualCommand.CommentText);
}
public void ZeroOperandParsing_DisableInterrupt()
{
var sourceCode = " di";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <DisableInterruptCommand>(parser.ParseLine(sourceCode));
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.DI, actualCommand.OpCode);
}
public void JumpTests_UnconditionalReturn()
{
var sourceCode = " RET";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <UnconditionalReturnCommand>(parser.ParseLine(sourceCode));
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.RET, actualCommand.OpCode);
}
public void NonParsable_OneSemicolon()
{
var sourceCode = " SAD (hl),de";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <UnparsableLine>(parser.ParseLine(sourceCode));
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual("Invalid OpCode", actualCommand.ErrorMessage);
}
public void ZeroOperandParsing_RRA()
{
var sourceCode = " rra";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <RotateRightCommand>(parser.ParseLine(sourceCode));
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.RRA, actualCommand.OpCode);
}
public void ArithmeticParing_NegateCommand()
{
var sourceCode = " neg";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <NegateCommand>(parser.ParseLine(sourceCode));
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.NEG, actualCommand.OpCode);
}
public void ZeroOperandParsing_NOP()
{
var sourceCode = " nop";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <NopCommand>(parser.ParseLine(sourceCode));
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.NOP, actualCommand.OpCode);
}
public void SingleOperandParsing_Subtract_NegativeImmediate()
{
var sourceCode = " SUB -4";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <SubCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <ImmediateOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.SUB, actualCommand.OpCode);
Assert.AreEqual(0xFC, actualOperand.ImmediateValue);
}
public void SingleOperandParsing_Decrement_IndirectRegister()
{
var sourceCode = " DEC (HL)";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <DecrementCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <IndirectRegisterOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.DEC, actualCommand.OpCode);
Assert.AreEqual(ExtendedRegister.HL, actualOperand.Register);
}
public void Jump_Unconditional_Address()
{
var sourceCode = " JP 194Fh";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <UnconditionalJumpCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <AddressWithoutParenthesisOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.JP, actualCommand.OpCode);
Assert.AreEqual(0x194F, actualOperand.MemoryAddress);
}
public void SingleOperandParsing_AndImmediate()
{
var sourceCode = " AND 5Ch";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <AndCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <ImmediateOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.AND, actualCommand.OpCode);
Assert.AreEqual(0x5C, actualOperand.ImmediateValue);
}
public void JumpTests_UnconditionalCallCommand()
{
var sourceCode = " CALL 45B2h";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <UnconditionalCallCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <AddressWithoutParenthesisOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.CALL, actualCommand.OpCode);
Assert.AreEqual(0x45b2, actualOperand.MemoryAddress);
}
public void ArithmeticParing_SubCommand()
{
var sourceCode = " sub B";
var parser = new Z80LineParser("#", "");
var actualCommand = AssertExtension.IsCorrectCommandType <SubCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <RegisterOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.SUB, actualCommand.OpCode);
Assert.AreEqual(Register.B, actualOperand.Register);
}
public void JumpRelative_Unconditional_Labeled()
{
var sourceCode = " JR elsewhere";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <UnconditionalRelativeJumpCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <LabeledAddressWithoutParenthesisOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.JR, actualCommand.OpCode);
Assert.AreEqual("elsewhere", actualOperand.Label);
}
public void Jump_Unconditional_IndirectRegister()
{
var sourceCode = " JP (IX)";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <UnconditionalJumpCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <IndirectRegisterOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.JP, actualCommand.OpCode);
Assert.AreEqual(ExtendedRegister.IX, actualOperand.Register);
}
public void SingleOperandParsing_PopCommand()
{
var sourceCode = " POP AF";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <PopCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <RegisterExtendedOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.POP, actualCommand.OpCode);
Assert.AreEqual(ExtendedRegister.AF, actualOperand.Register);
}
public void SingleOperandParsing_InterruptMode()
{
var sourceCode = " IM 1";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <InterruptModeCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <ImmediateOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.IM, actualCommand.OpCode);
Assert.AreEqual(1, actualOperand.ImmediateValue);
}
public void SingleOperandParsing_Or_Register()
{
var sourceCode = " OR D";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <OrCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <RegisterOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.OR, actualCommand.OpCode);
Assert.AreEqual(Register.D, actualOperand.Register);
}
public void SingleOperandParsing_AndIndirectAddress()
{
var sourceCode = " AND (HL)";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <AndCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <IndirectRegisterOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.AND, actualCommand.OpCode);
Assert.AreEqual(ExtendedRegister.HL, actualOperand.Register);
}
public void JumpTests_UnconditionalCallCommand_ToLabeledAddress()
{
var sourceCode = " CALL overThere";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <UnconditionalCallCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <LabeledAddressWithoutParenthesisOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.CALL, actualCommand.OpCode);
Assert.AreEqual("overThere", actualOperand.Label);
}
public void SingleOperandParsing_Xor_Immediate()
{
var sourceCode = " XOR 8Ah";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <XorCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <ImmediateOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.XOR, actualCommand.OpCode);
Assert.AreEqual(0x8A, actualOperand.ImmediateValue);
}
public void ZeroOperandParsing_WithComment()
{
var sourceCode = " nop ;This is a trailing comment";
var parser = new Z80LineParser();
var command = parser.ParseLine(sourceCode);
var actualCommand = AssertExtension.IsCorrectCommandType <NopCommand>(command);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.NOP, actualCommand.OpCode);
Assert.AreEqual("This is a trailing comment", actualCommand.TrailingComment);
}
public void JumpTests_DJNZ()
{
var sourceCode = " DJNZ loop1";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <DjnzCommand>(parser.ParseLine(sourceCode));
var actualOperand = AssertExtension.IsCorrectOperandType <LabeledAddressWithoutParenthesisOperand>(actualCommand.Operand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(OpCode.DJNZ, actualCommand.OpCode);
Assert.AreEqual("loop1", actualOperand.Label);
}
public void LoadParing_LoadCommand_EightBitImmediate()
{
var sourceCode = " LD B,132";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <LoadCommand>(parser.ParseLine(sourceCode));
var actualSourceOperand = AssertExtension.IsCorrectOperandType <ImmediateOperand>(actualCommand.SourceOperand);
var actualDestinationOperand = AssertExtension.IsCorrectOperandType <RegisterOperand>(actualCommand.DestinationOperand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(132, actualSourceOperand.ImmediateValue);
Assert.AreEqual(Register.B, actualDestinationOperand.Register);
}
public void LoadParing_LoadCommand_HexNumberNoPrefix()
{
var sourceCode = " LD B,AA";
var parser = new Z80LineParser("", "");
var actualCommand = AssertExtension.IsCorrectCommandType <LoadCommand>(parser.ParseLine(sourceCode));
var actualSourceOperand = AssertExtension.IsCorrectOperandType <ImmediateOperand>(actualCommand.SourceOperand);
var actualDestinationOperand = AssertExtension.IsCorrectOperandType <RegisterOperand>(actualCommand.DestinationOperand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(0xAA, actualSourceOperand.ImmediateValue);
Assert.AreEqual(Register.B, actualDestinationOperand.Register);
}
public void LoadParing_LoadCommand_FromMemory_SixteenBit()
{
var sourceCode = " LD BC,(#48a9)";
var parser = new Z80LineParser("#", "");
var actualCommand = AssertExtension.IsCorrectCommandType <LoadCommand>(parser.ParseLine(sourceCode));
var actualSourceOperand = AssertExtension.IsCorrectOperandType <ExtendedAddressOperand>(actualCommand.SourceOperand);
var actualDestinationOperand = AssertExtension.IsCorrectOperandType <RegisterExtendedOperand>(actualCommand.DestinationOperand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(0x48a9, actualSourceOperand.MemoryAddress);
Assert.AreEqual(ExtendedRegister.BC, actualDestinationOperand.Register);
}
public void LoadParing_LoadCommand_IndirectRegisterOperand()
{
var sourceCode = " LD (HL),47h";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <LoadCommand>(parser.ParseLine(sourceCode));
var actualSourceOperand = AssertExtension.IsCorrectOperandType <ImmediateOperand>(actualCommand.SourceOperand);
var actualDestinationOperand = AssertExtension.IsCorrectOperandType <IndirectRegisterOperand>(actualCommand.DestinationOperand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(0x47, actualSourceOperand.ImmediateValue);
Assert.AreEqual(ExtendedRegister.HL, actualDestinationOperand.Register);
}
public void LoadParing_LoadCommand_TwoExtendedRegisters()
{
var sourceCode = " LD DE,HL";
var parser = new Z80LineParser();
var actualCommand = AssertExtension.IsCorrectCommandType <LoadCommand>(parser.ParseLine(sourceCode));
var actualSourceOperand = AssertExtension.IsCorrectOperandType <RegisterExtendedOperand>(actualCommand.SourceOperand);
var actualDestinationOperand = AssertExtension.IsCorrectOperandType <RegisterExtendedOperand>(actualCommand.DestinationOperand);
Assert.AreEqual(sourceCode, actualCommand.SourceText);
Assert.AreEqual(ExtendedRegister.HL, actualSourceOperand.Register);
Assert.AreEqual(ExtendedRegister.DE, actualDestinationOperand.Register);
}
