public CPU(Memory memory, PPU ppu, LoadUnit loadUnit, ALU alu, MiscUnit miscUnit, JumpUnit jumpUnit, BitUnit bitUnit)
{
this.ppu = ppu;
this.loadUnit = loadUnit;
this.alu = alu;
this.miscUnit = miscUnit;
this.jumpUnit = jumpUnit;
this.bitUnit = bitUnit;
this.loadUnit.TickEvent += Tick;
this.alu.TickEvent += Tick;
this.jumpUnit.TickEvent += Tick;
this.bitUnit.TickEvent += Tick;
CreateLoadUnitOpCodes();
CreateALUOpCodes();
CreateMiscOpCodes();
CreateJumpOpCodes();
CreateBitUnitOpCodes();
this.memory = memory;
this.timer = new Timer(memory);
this.memory.DivResetEvent += DivResetHandler;
interruptVector = new Dictionary <Interrupt, ushort>
{
{ Interrupt.VBlank, 0x40 },
{ Interrupt.LCDStat, 0x48 },
{ Interrupt.Timer, 0x50 },
{ Interrupt.Serial, 0x58 },
{ Interrupt.Joypad, 0x60 }
};
}
public CPUTests(ITestOutputHelper testOutputHelper)
{
this.testOutputHelper = testOutputHelper;
memory = new Memory(new byte[]
{
IMMEDIATE_BYTE,
(IMMEDIATE_WORD >> 8) & 0xFF
});
display = new BlankDisplay();
ppu = new PPU(memory, display);
loadUnit = A.Fake <LoadUnit>();
alu = A.Fake <ALU>();
miscUnit = A.Fake <MiscUnit>();
jumpUnit = A.Fake <JumpUnit>();
bitUnit = A.Fake <BitUnit>();
cpu = new CPU(memory, ppu, loadUnit, alu, miscUnit, jumpUnit, bitUnit)
{
A = 0x0A,
B = 0x0B,
C = 0x0C,
D = 0x0D,
E = 0x0E,
H = 0xAA,
L = 0xBB,
PC = 0x00,
SP = 0xFF
};
memory.WriteByte(0xAABB, MEM_HL_BYTE);
}
public void WriteToAddressTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
byte source = 0x66;
loadUnit.WriteToAddress(0xABBA, source);
Assert.Equal(0x66, memory.ReadByte(0xABBA));
}
public void LoadTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
byte to = 0x00;
byte from = 0xFF;
loadUnit.Load(ref to, from);
Assert.Equal(0xFF, to);
}
public void WriteWordToAddressTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
ushort value = 0xABCD;
loadUnit.WriteToAddress(0xABBA, value);
Assert.Equal(0xCD, memory.ReadByte(0xABBA));
Assert.Equal(0xAB, memory.ReadByte(0xABBB));
}
public void LoadWordToWord()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
ushort to = 0x00;
ushort from = 0xABCD;
loadUnit.Load(ref to, from);
Assert.Equal(0xABCD, to);
}
public void LoadBytesToWord()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
ushort to = 0x00;
byte fromHigh = 0xAB;
byte fromLow = 0xCD;
loadUnit.Load(ref to, fromHigh, fromLow);
Assert.Equal(0xABCD, to);
}
public void LoadFromAddressTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
byte to = 0x00;
memory.WriteByte(0xABBA, 0x10);
loadUnit.LoadFromAddress(ref to, 0xAB, 0xBA);
Assert.Equal(0x10, to);
}
public void PushTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
ushort pointer = 0xDFFF;
byte valueHigh = 0xAB;
byte valueLow = 0xCD;
loadUnit.Push(ref pointer, valueHigh, valueLow);
Assert.Equal(0xABCD, memory.ReadWord(pointer));
Assert.Equal(0xDFFD, pointer);
}
public void LoadWordTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
byte high = 0x00;
byte low = 0x00;
ushort from = 0xABCD;
loadUnit.Load(ref high, ref low, from);
Assert.Equal(0xAB, high);
Assert.Equal(0xCD, low);
}
public void WriteToAddressAndIncrementTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
byte source = 0xDD;
byte addrHigh = 0xAA;
byte addrLow = 0xFF;
loadUnit.WriteToAddressAndIncrement(ref addrHigh, ref addrLow, source, 1);
Assert.Equal(0xDD, memory.ReadByte(0xAAFF));
Assert.Equal(0xAB, addrHigh);
Assert.Equal(0x00, addrLow);
}
static void Main(string[] args)
{
var cubing = new Cubing.Cubing();
cubing.Boxes = generate_boxes(new Box(600, 400, 400), new Box(250, 150, 120), 200);
var pallet = new LoadUnit(1000, 1200, 1200);
cubing.loadUnit = pallet;
cubing.cubing_FFD();
File.WriteAllText(@"C:\Users\liweijun\Desktop\新建文件夹\Elkeurti\cubingData.json", JsonConvert.SerializeObject(cubing));
}
public void PopWithFlagsTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
byte destHigh = 0x00;
byte destLow = 0b10010000;
ushort value = 0xC000;
memory.WriteWord(0xC000, 0x1234);
loadUnit.PopWithFlags(ref destHigh, ref destLow, ref value, ref destLow);
Assert.Equal(0x12, destHigh);
Assert.Equal(0x34 & 0xF0, destLow);
Assert.Equal(0xC002, value);
}
public void LoadFromAddressAndIncrementTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
byte dest = 0x00;
byte addrHigh = 0xAA;
byte addrLow = 0xFF;
memory.WriteByte(0xAAFF, 0xEE);
loadUnit.LoadFromAddressAndIncrement(ref dest, ref addrHigh, ref addrLow, 1);
Assert.Equal(0xEE, dest);
Assert.Equal(0xAB, addrHigh);
Assert.Equal(0x00, addrLow);
}
public void LoadAdjustedPositiveTest()
{
var memory = new Memory();
var loadUnit = new LoadUnit(memory);
byte H = 0xF0;
byte L = 0xF0;
ushort SP = 0x0000;
byte flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0001, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x0001;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0002, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x000F;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0010, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00100000, flags);
SP = 0x0010;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0011, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x001F;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0020, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00100000, flags);
SP = 0x007F;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0080, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00100000, flags);
SP = 0x0080;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0081, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x00FF;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0100, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00110000, flags);
SP = 0x0100;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0101, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x0F00;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0F01, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x1F00;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x1F01, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x1000;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x1001, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0x7FFF;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x8000, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00110000, flags);
SP = 0x8000;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x8001, BitUtils.BytesToUshort(H, L));
Assert.Equal(0x0, flags);
SP = 0xFFFF;
flags = 0x0;
loadUnit.LoadAdjusted(ref H, ref L, SP, 0x01, ref flags);
Assert.Equal(0x0000, BitUtils.BytesToUshort(H, L));
Assert.Equal(0b00110000, flags);
}
