public void _Bnnn_JP_v0_addr()
{
var registers = new RegisterModule();
registers.SetGeneralValue(0,
0x12);
var emulator = CHIP8Factory.GetChip8(registers: registers);
var instructions = new byte[]
{
0xB1,
0x23
};
emulator.LoadProgram(instructions);
emulator.Tick += (e,
a) =>
{
emulator.Stop();
};
emulator.Start();
Assert.Equal(0x123 + 0x12,
GetProgramCounter(emulator));
}
public void _Cxkk_RND_vx_byte(byte kk,
byte rand)
{
var registers = new RegisterModule();
var random = new TestRandom(rand);
var emulator = CHIP8Factory.GetChip8(registers: registers,
random: random);
var instructions = new byte[]
{
0xC0, //Set v0 = kk & random byte
kk
};
emulator.LoadProgram(instructions);
emulator.Tick += (e,
a) =>
{
emulator.Stop();
};
emulator.Start();
Assert.Equal(rand & kk,
registers.GetGeneralValue(0));
}
public void _8xy3_XOR_vx_vy(byte x,
byte y)
{
/*
* 8xy3 - Performs a bitwise exclusive OR on the values of Vx and Vy, then stores the result in Vx.
*/
var registers = new RegisterModule();
var emulator = CHIP8Factory.GetChip8(registers: registers);
var instructions = new byte[]
{
0x60, //LD v0 with x,
x,
0x61, //LD v1 with y
y,
0x80, //Bitwise xor, store in v0
0x13
};
emulator.LoadProgram(instructions);
emulator.Start();
var expectedResult = x ^ y;
Assert.Equal(expectedResult,
registers.GetGeneralValue(0));
}
public static void RabbitMQTest()
{
var _container = new AutoFacServiceLocator();
_container.ScanAssemblyAsPerLifetimeScope <TestConsumer1>();
_container.Map <IExceptionProcess, ExceptionProcess>();
RegisterModule.Register(_container);
_container.UseAsDefault(true);
var config = new RabbitMQConfig {
Host = "localhost:/mis", Username = "******", Password = "******"
};
//_container.BusOnRabbitMq(config, x => x.SubscribeAt(config.Host, new DefaultConsumeConfigurator(_container)));
_container.BusOnRabbitMq(config, x => x.PublishAt(config.Host, new DefaultConsumeConfigurator(_container)));
var publisher = ServiceLocator.Current.GetInstance <IEventPublisher>();
publisher.Publish <RabbitTestEvent1>(new RabbitTestEvent1 {
UserId = 2, UserName = Guid.NewGuid().ToString()
}, "mis");
while (true)
{
publisher.Publish <RabbitTestEvent>(new RabbitTestEvent {
UserId = 2, UserName = Guid.NewGuid().ToString()
});
publisher.Publish <RabbitTestEvent2>(new RabbitTestEvent2 {
UserId = 3, UserName = Guid.NewGuid().ToString()
});
}
}
public void _Fx1E_add_I_Vx()
{
var registers = new RegisterModule();
registers.SetGeneralValue(0,
0x12);
registers.SetI(0x123);
var emulator = CHIP8Factory.GetChip8(registers: registers);
var instructions = new byte[]
{
0xF0, //Add v0 and I, store in I
0x1E
};
emulator.LoadProgram(instructions);
emulator.Tick += (e,
a) =>
{
emulator.Stop();
};
emulator.Start();
Assert.Equal(0x123 + 0x12,
registers.GetI());
}
public async Task UpdateAsync()
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
RegisterModule regMod = (RegisterModule)await ModuleDefinition.CreateUniqueModuleAsync(typeof(RegisterModule));
LoginModule loginMod = (LoginModule)await ModuleDefinition.CreateUniqueModuleAsync(typeof(LoginModule));
bool closeOnLogin;
Manager.TryGetUrlArg <bool>("CloseOnLogin", out closeOnLogin, false);
ModuleAction logAction = await loginMod.GetAction_LoginAsync(config.LoginUrl, Force : true, CloseOnLogin : closeOnLogin);
if (logAction != null)
{
logAction.AddToOriginList = false;
}
Actions.New(logAction);
ModuleAction regAction = await regMod.GetAction_RegisterAsync(config.RegisterUrl, Force : true, CloseOnLogin : closeOnLogin);
if (regAction != null)
{
regAction.AddToOriginList = false;
}
Actions.New(regAction);
}
} // for external login only
public async Task UpdateAsync()
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
RegisterModule regMod = (RegisterModule)await ModuleDefinition.CreateUniqueModuleAsync(typeof(RegisterModule));
bool closeOnLogin;
Manager.TryGetUrlArg <bool>("CloseOnLogin", out closeOnLogin, false);
ForgotPasswordModule pswdMod = (ForgotPasswordModule)await ModuleDefinition.CreateUniqueModuleAsync(typeof(ForgotPasswordModule));
ModuleAction pswdAction = await pswdMod.GetAction_ForgotPasswordAsync(config.ForgotPasswordUrl, CloseOnLogin : closeOnLogin);
if (pswdAction != null)
{
pswdAction.AddToOriginList = false;
}
Actions.New(pswdAction);
ModuleAction registerAction = await regMod.GetAction_RegisterAsync(config.RegisterUrl, Force : true, CloseOnLogin : closeOnLogin);
if (registerAction != null)
{
registerAction.AddToOriginList = false;
}
Actions.New(registerAction);
}
public MainWindow()
{
displayDictionary = new Dictionary <Point, Rectangle>();
for (var x = 0; x < 64; x++)
{
for (var y = 0; y < 32; y++)
{
var point = new Point(x,
y);
displayDictionary[point] = null;
}
}
var registers = new RegisterModule();
emulator = CHIP8Factory.GetChip8(DisplayEmulatorScreen,
registers,
new StackModule(),
new MemoryModule(Enumerable.Repeat <byte>(0x0,
4096)));
emulator.ToneOn += this.ToneOn;
emulator.ToneOff += this.ToneOff;
var bytes = File.ReadAllBytes("pong.ch8");
emulator.LoadProgram(bytes);
InitializeComponent();
this.KeyDown += MainWindow_KeyDown;
this.KeyUp += MainWindow_KeyUp;
}
public void _Fx33_LD_B_Vx()
{
/*
* Stores the BCD of vx in I, I+1, and I+2 of memory
* 125:
* Hex: 0x7D
* BCD: 0001 0010 0101
*/
var registers = new RegisterModule();
registers.SetGeneralValue(0,
0x7D);
registers.SetI(0x123);
var memory = new MemoryModule(Enumerable.Repeat((byte)0x0,
4096));
var emulator = CHIP8Factory.GetChip8(registers: registers,
mem: memory);
var instructions = new byte[]
{
0xF0, //Store BCD of v0 in memory
0x33
};
emulator.LoadProgram(instructions);
emulator.Tick += (e,
a) =>
{
emulator.Stop();
};
emulator.Start();
var startPoint = registers.GetI();
var hundreds = memory[startPoint];
startPoint++;
var tens = memory[startPoint];
startPoint++;
var ones = memory[startPoint];
Assert.Equal(0x1,
hundreds);
Assert.Equal(0x2,
tens);
Assert.Equal(0x5,
ones);
}
private PreferencePanel[] GetPreferencePanel(ApplicationMenuModule amm)
{
string module = amm.Namespace.Module;
amm.Namespace.Application = "ModuleData.RegisterModule";
RegisterModule registerTable = (RegisterModule)DllManager.CreateIstance(amm.Namespace, null);
if (registerTable != null)
{
return(registerTable.RegisterPreferences());
}
return(null);
}
void Start()
{
RAM = GameObject.Find("RAM").GetComponent <RAMModule>();
IR = GameObject.Find("Instruction Register").GetComponent <InstructionRegisterModule>();
ALU = GameObject.Find("ALU").GetComponent <ALUModule>();
PC = GameObject.Find("Program Counter").GetComponent <ProgramCounterModule>();
BUS = GameObject.Find("Bus").GetComponent <BusModule>();
A = GameObject.Find("Register_A").GetComponent <RegisterModule>();
B = GameObject.Find("Register_B").GetComponent <RegisterModule>();
O = GameObject.Find("Output Register").GetComponent <RegisterModule>();
externalFunc = GameObject.Find("ExternalFuncs").GetComponent <ExternalFuncs>();
assembler = GameObject.Find("Assembler").GetComponent <Assembler>();
}
private static void AttachAddOn(object obj, NameSpace ns)
{
if (obj is ERPFramework.Forms.IDocument)
{
foreach (ApplicationMenuModule amm in ModuleManager.ModuleList)
{
string module = amm.Namespace.Module;
amm.Namespace.Application = "ModuleData.RegisterModule";
RegisterModule registerModule = (RegisterModule)DllManager.CreateIstance(amm.Namespace, null);
if (registerModule != null)
{
registerModule.Addon(obj as ERPFramework.Forms.IDocument, ns);
}
}
}
}
public void Correctly_Clears_Display_CLS()
{
var registers = new RegisterModule();
bool[,] display = null;
Task WriteDisplay(bool[,] values)
{
display = values;
return(Task.CompletedTask);
}
var emulator = CHIP8Factory.GetChip8(WriteDisplay,
registers);
registers.SetGeneralValue(0,
0x0);
var instructions = new byte[]
{
/* Load location of sprite for '0' to I */
0xF0,
0x29,
/* Draw 5 byte sized sprite at 0,0 */
0xD0,
0x05,
/* Clear screen */
0x00,
0xE0
};
emulator.LoadProgram(instructions);
emulator.Start();
Assert.NotNull(display);
for (var x = 0; x < display.GetLength(0); x++)
{
for (var y = 0; y < display.GetLength(1); y++)
{
Assert.False(display[x,
y]);
}
}
}
public async Task SendNewUserCreatedAsync(UserDefinition user)
{
// get the registration module for some defaults
RegisterModule regMod = (RegisterModule)await ModuleDefinition.CreateUniqueModuleAsync(typeof(RegisterModule));
ModuleAction reject = await regMod.GetAction_RejectAsync(user.UserName);
SendEmail sendEmail = new SendEmail();
object parms = new {
User = user,
RejectUrl = reject.GetCompleteUrl(),
};
string subject = this.__ResStr("notifyNewUserSubject", "New account for user {0} - site {1}", user.UserName, Manager.CurrentSite.SiteDomain);
await sendEmail.PrepareEmailMessageAsync(null, subject, await sendEmail.GetEmailFileAsync(Package.GetCurrentPackage(this), "New Account Created.txt"), Parameters : parms);
await sendEmail.SendAsync(false);
SendingEmailAddress = await sendEmail.GetSendingEmailAddressAsync();
}
public void _Annn_LD_I_addr()
{
var registers = new RegisterModule();
var emulator = CHIP8Factory.GetChip8(registers: registers);
var instructions = new byte[]
{
0xA1,
0x23
};
emulator.LoadProgram(instructions);
emulator.Start();
Assert.Equal(0x123,
registers.GetI());
}
public void _9xy0_SNE_vx_vy(byte vx,
byte vy)
{
var registerModule = new RegisterModule();
registerModule.SetGeneralValue(0,
vx);
registerModule.SetGeneralValue(1,
vy);
var instructions = new byte[]
{
0x90, //Inc program counter by 2 if v0 == v1
0x10
};
var chip = CHIP8Factory.GetChip8(registers: registerModule);
chip.LoadProgram(instructions);
chip.Tick += (c,
e) =>
{
chip.Stop();
};
chip.Start();
var nextInstruction = 514;
var expectedAddress = nextInstruction;
if (vx != vy)
{
expectedAddress += 2;
}
var programCounter = GetProgramCounter(chip);
Assert.Equal(expectedAddress,
programCounter);
}
public void _6xkk_LD_vx_byte()
{
/*
* 6xkk - LD Vx, byte Set Vx = kk. The interpreter puts the value kk into register Vx.
*/
var registers = new RegisterModule();
var emulator = CHIP8Factory.GetChip8(registers: registers);
var instructions = new byte[]
{
0x60, //LD v0 with byte 0x12
0x12
};
emulator.LoadProgram(instructions);
emulator.Start();
Assert.Equal(0x12,
registers.GetGeneralValue(0));
}
private static bool RegisterModule(NameSpace nspace)
{
nspace.Application = "ModuleData.RegisterModule";
RegisterModule registerTable = (RegisterModule)DllManager.CreateIstance(nspace, null);
if (registerTable != null)
{
if (SerialManager.IsActivate(registerTable.Application(), registerTable.Module()))
{
bool bOk = registerTable.CreateTable(GlobalInfo.DBaseInfo.dbManager.DB_Connection, GlobalInfo.UserInfo.userType);
if (bOk)
{
registerTable.RegisterCountersAndCodes();
}
}
else
{
return(false);
}
}
return(true);
}
private static void AttachPreferences(object obj, NameSpace nameSpace)
{
if (obj is ERPFramework.Preferences.PreferenceForm)
{
ERPFramework.Preferences.PreferenceForm form = obj as ERPFramework.Preferences.PreferenceForm;
RegisterModule registerModule = (RegisterModule)DllManager.CreateIstance(new NameSpace("ERPManager.ERPManager.ModuleData.RegisterModule"), null);
if (registerModule != null)
{
form.AddPanel(registerModule.RegisterPreferences());
}
foreach (ApplicationMenuModule amm in ModuleManager.ModuleList)
{
string module = amm.Namespace.Module;
amm.Namespace.Application = "ModuleData.RegisterModule";
registerModule = (RegisterModule)DllManager.CreateIstance(amm.Namespace, null);
if (registerModule != null)
{
form.AddPanel(registerModule.RegisterPreferences());
}
}
}
}
public void _8xy0_LD_vx_vy()
{
/*
* 8xy0 - Stores the value of register Vy in register Vx.
*/
var registers = new RegisterModule();
var emulator = CHIP8Factory.GetChip8(registers: registers);
var instructions = new byte[]
{
0x61, //LD v1 with byte 0x12
0x12,
0x80, // Store value at v1 in v0
0x10
};
emulator.LoadProgram(instructions);
emulator.Start();
Assert.Equal(0x12,
registers.GetGeneralValue(0));
}
public void _7xkk_LD_vx_byte()
{
/*
* 7xkk - Adds the value kk to the value of register Vx, then stores the result in Vx.
*/
var registers = new RegisterModule();
var emulator = CHIP8Factory.GetChip8(registers: registers);
var instructions = new byte[]
{
0x60, //LD v0 with byte 0x12
0x12,
0x70, // Add 0x10 to v0 and save it in v0
0x10
};
emulator.LoadProgram(instructions);
emulator.Start();
Assert.Equal(0x22,
registers.GetGeneralValue(0));
}
public void _Fx65_LD_Vx_I()
{
/*
* Set registers v0 through vx from memory starting at I
*/
var registers = new RegisterModule();
registers.SetI(0x278);
var startPoint = registers.GetI();
var memory = new MemoryModule(Enumerable.Repeat((byte)0x0,
4096));
memory[startPoint] = 0x7D;
startPoint++;
memory[startPoint] = 0x55;
startPoint++;
memory[startPoint] = 0x18;
startPoint++;
memory[startPoint] = 0x90;
var emulator = CHIP8Factory.GetChip8(registers: registers,
mem: memory);
var instructions = new byte[]
{
0xF3, //Set v0 - v3 from memory
0x65
};
emulator.LoadProgram(instructions);
emulator.Tick += (e,
a) =>
{
emulator.Stop();
};
emulator.Start();
var v0 = registers.GetGeneralValue(0);
var v1 = registers.GetGeneralValue(1);
var v2 = registers.GetGeneralValue(2);
var v3 = registers.GetGeneralValue(3);
Assert.Equal(0x7D,
v0);
Assert.Equal(0x55,
v1);
Assert.Equal(0x18,
v2);
Assert.Equal(0x90,
v3);
}
public void _Fx55_LD_I_Vx()
{
/*
* Stores registers v0 through vx in memory starting at I
*/
var registers = new RegisterModule();
registers.SetGeneralValue(0,
0x7D);
registers.SetGeneralValue(1,
0x55);
registers.SetGeneralValue(2,
0x18);
registers.SetGeneralValue(3,
0x90);
registers.SetI(0x278);
var memory = new MemoryModule(Enumerable.Repeat((byte)0x0,
4096));
var emulator = CHIP8Factory.GetChip8(registers: registers,
mem: memory);
var instructions = new byte[]
{
0xF3, //Store v0 - v3 in memory
0x55
};
emulator.LoadProgram(instructions);
emulator.Tick += (e,
a) =>
{
emulator.Stop();
};
emulator.Start();
var startPoint = 0x278;
var v0 = memory[startPoint];
startPoint++;
var v1 = memory[startPoint];
startPoint++;
var v2 = memory[startPoint];
startPoint++;
var v3 = memory[startPoint];
Assert.Equal(0x7D,
v0);
Assert.Equal(0x55,
v1);
Assert.Equal(0x18,
v2);
Assert.Equal(0x90,
v3);
}
public void Correctly_Draws_Zero_Sprite_Dxyn(byte xOffset,
byte yOffset)
{
var registers = new RegisterModule();
bool[,] display = null;
Task WriteDisplay(bool[,] values)
{
display = values;
return(Task.CompletedTask);
}
var emulator = CHIP8Factory.GetChip8(WriteDisplay,
registers);
registers.SetGeneralValue(3,
0x0);
registers.SetGeneralValue(0,
xOffset);
registers.SetGeneralValue(1,
yOffset);
var instructions = new byte[]
{
/* Load location of sprite for '0' to I */
0xF3,
0x29,
/* Draw 5 byte sized sprite at (v0, v1) */
0xD0,
0x15
};
emulator.LoadProgram(instructions);
emulator.Start();
void AssertDisplay(int x,
int y,
bool pixelValue)
{
var validY = false;
x = x - xOffset;
y = y - yOffset;
switch (x)
{
case 0:
case 3:
// Column 1 & 4 all on
validY = pixelValue;
break;
case 1:
case 2:
// For the middle 2 columns only the top and bottom should be on
if (y == 0 ||
y == 4)
{
validY = pixelValue;
}
else
{
validY = !pixelValue;
}
break;
default:
// Everything past 4 should be off
validY = !pixelValue;
break;
}
Assert.True(validY,
$"Invalid pixel at sprite coordinate ({x},{y}), true coordinate({x + xOffset}, {y + yOffset}). {pixelValue}.");
}
Assert.NotNull(display);
// Check the 8x5 area the sprite displays in
for (var x = xOffset; x < 8 + xOffset; x++)
{
for (var y = yOffset; y < 5 + yOffset; y++)
{
AssertDisplay(x,
y,
display[x,
y]);
}
}
}
public void Correctly_Draws_Manual_Zero_Sprite_Dxyn()
{
/*
* Dxyn - DRW Vx, Vy, nibble
* Display n-byte sprite starting at memory location I at (Vx, Vy), set VF = collision.
*/
// Copy of the 0 sprite data we load
var zeroSpriteData = new byte[]
{
0xF0,
0x90,
0x90,
0x90,
0xF0
};
// Set I to start of sprite
var setIInstruction = new byte[]
{
0xAD,
0xDD
};
// Draw 5 bytes at 0,0 from mem address I
var drawInstruction = new byte[]
{
0xD0,
0x05
};
var registers = new RegisterModule();
bool[,] display = null;
Task WriteDisplay(bool[,] values)
{
display = values;
return(Task.CompletedTask);
}
var ram = Enumerable.Repeat <byte>(0x0,
4096)
.ToArray();
const int spriteStart = 0xDDD;
// Copy the data starting at FFF
for (var i = spriteStart; i < spriteStart + zeroSpriteData.Length; i++)
{
ram[i] = zeroSpriteData[i - spriteStart];
}
var memory = new MemoryModule(ram);
var emulator = CHIP8Factory.GetChip8(WriteDisplay,
registers,
new StackModule(),
memory);
registers.SetGeneralValue(0,
0x0);
var instructions = setIInstruction.Concat(drawInstruction)
.ToArray();
emulator.LoadProgram(instructions);
emulator.Start();
void AssertDisplay(int x,
int y,
bool pixelValue)
{
var validY = false;
switch (x)
{
case 0:
case 3:
// Column 1 & 4 all on
validY = pixelValue;
break;
case 1:
case 2:
// For the middle 2 columns only the top and bottom should be on
if (y == 0 ||
y == 4)
{
validY = pixelValue;
}
else
{
validY = !pixelValue;
}
break;
default:
// Everything past 4 should be off
validY = !pixelValue;
break;
}
Assert.True(validY,
$"Invalid pixel at {x},{y}. {pixelValue}.");
}
Assert.NotNull(display);
// Check the 8x5 area the sprite displays in
for (var x = 0; x < 8; x++)
{
for (var y = 0; y < 5; y++)
{
AssertDisplay(x,
y,
display[x,
y]);
}
}
}
