Added tests for MOS6502.Assembler, most still pending completion.

dummy.js

@@ -12,5 +12,5 @@ src += "DEX             ;Decrement counter\n";
 src += "BNE CLRM1       ;Not zero, continue checking\n";
 src += "RTS             ;Return\n"
 
-var res = asm.compile(src);
+var res = asm.compile(src).result();
 console.log(res);

package.json

@@ -4,7 +4,7 @@
   "description": "Fantasy 8Bit (F8) chip emulator",
   "main": "f8.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "mocha"
   },
   "keywords": [
     "fantasy",

src/MOS6502.js

@@ -190,6 +190,8 @@ class Assembler{
         if (tB !== null){
           if (tB === "X")
             mode = "zX";
+          if (tB === "Y")
+            mode = "zY";
         } else {
           mode = "z";
         }
@@ -311,7 +313,8 @@ class Assembler{
             return true;
           };
 
-          let StoreOp = (codes, mint, maxt) => {
+          let StoreOp = (codes, mint, maxt, zpm) => {
+            zpm = (zpm === "zY") ? "zY" : "zX";
             if (tokens.length >= mint && tokens.length <= maxt){
               let mv = this.__AddrModeVal(tokens[1], (tokens.length === 3) ? tokens[2].toUpperCase() : null);
               let modena = true;
@@ -330,8 +333,9 @@ class Assembler{
                     op.push(mv[1]);
                     this.__PC += 2;
                   } break;
+                case "zY":
                 case "zX":
-                  modena = codes[2] === null;
+                  modena = (mv[0] === zpm && codes[2] === null);
                   if (!modena){
                     op.push(codes[2]);
                     op.push(mv[1]);
@@ -562,7 +566,7 @@ class Assembler{
               procFailed = StoreOp([0xA9, 0xA5, 0xB5, 0xAD, 0xBD, 0xB9, 0xA1, 0xB1], 2, 3); break;
 // --- LDX
             case 'ldx':
-              procFailed = StoreOp([0xA2, 0xA6, 0xB6, 0xAE, 0xBE, null, null, null], 2, 3); break;
+              procFailed = StoreOp([0xA2, 0xA6, 0xB6, 0xAE, 0xBE, null, null, null], 2, 3, "zY"); break;
 // --- LDY
             case 'ldy':
               procFailed = StoreOp([0xA0, 0xA4, 0xB4, 0xAC, 0xBC, null, null, null], 2, 3); break;
@@ -639,7 +643,7 @@ class Assembler{
               procFailed = StoreOp([null, 0x85, 0x95, 0x8D, 0x9D, 0x99, 0x81, 0x91], 2, 3); break;
 // --- STX
             case 'stx':
-              procFailed = StoreOp([null, 0x86, 0x96, 0x8E, null, null, null, null], 2, 3); break;
+              procFailed = StoreOp([null, 0x86, 0x96, 0x8E, null, null, null, null], 2, 3, "zY"); break;
 // --- STY
             case 'sty':
               procFailed = StoreOp([null, 0x84, 0x94, 0x8C, null, null, null, null], 2, 3); break;

test/MOS6502.spec.js

@@ -0,0 +1,442 @@
+const expect = require('chai').expect;
+const mos6502 = require('../src/MOS6502.js');
+
+
+describe("Testing MOS6502 Systems...", function(){
+  describe("Testing MOS6502 Assembler...", function(){
+    var asm = new mos6502.Assembler();
+
+    it(".reset()", function(){
+      asm.compile("ADC $44");
+      asm.reset();
+      expect(asm.PC).to.equal(0);
+      expect(Object.keys(asm.variables).length).to.equal(0);
+      expect(Object.keys(asm.jumplabels).length).to.equal(0);
+      expect(asm.result().length).to.equal(0);
+    });
+
+    it(".result()", function(){
+      asm.reset();
+      asm.compile("ADC $44");
+      expect(asm.result().length).to.be.gt(0);
+    });
+
+    describe(".compile()", function(){
+      it("Variable definition", function(){
+        asm.compile("define TAG $44");
+        let vars = asm.variables;
+        expect(vars).to.have.key('TAG');
+        expect(vars['TAG']).to.equal(0x44);
+      });
+
+      it("Jump labels", function(){
+        let pc = asm.PC;
+        asm.compile("loop:\nBNE loop");
+        let jmp = asm.jumplabels;
+        expect(jmp).to.have.key('loop');
+        expect(jmp['loop']).to.equal(pc);
+      });
+
+      it("ADC Immediate", function(){
+        asm.reset();
+        asm.compile("ADC #$44");
+        let res = asm.result();
+        expect(res.length).to.equal(2);
+        expect(res[0]).to.equal(0x69);
+        expect(res[1]).to.equal(0x44);
+      });
+
+      it("ADC Zero Page", function(){
+        asm.reset();
+        asm.compile("ADC $44");
+        let res = asm.result();
+        expect(res.length).to.equal(2);
+        expect(res[0]).to.equal(0x65);
+        expect(res[1]).to.equal(0x44);
+      });
+
+      it("ADC Zero Page, X", function(){
+        asm.reset();
+        asm.compile("ADC $44, X");
+        let res = asm.result();
+        expect(res.length).to.equal(2);
+        expect(res[0]).to.equal(0x75);
+        expect(res[1]).to.equal(0x44);
+      });
+
+      it("ADC Absolute", function(){
+        asm.reset();
+        asm.compile("ADC $4400");
+        let res = asm.result();
+        expect(res.length).to.equal(3);
+        expect(res[0]).to.equal(0x6D);
+        expect(res[1]).to.equal(0x00);
+        expect(res[2]).to.equal(0x44);
+      });
+
+      it("ADC Absolute, X", function(){
+        asm.reset();
+        asm.compile("ADC $4400,X");
+        let res = asm.result();
+        expect(res.length).to.equal(3);
+        expect(res[0]).to.equal(0x7D);
+        expect(res[1]).to.equal(0x00);
+        expect(res[2]).to.equal(0x44);
+      });
+
+      it("ADC Absolute, Y", function(){
+        asm.reset();
+        asm.compile("ADC $4400, Y");
+        let res = asm.result();
+        expect(res.length).to.equal(3);
+        expect(res[0]).to.equal(0x79);
+        expect(res[1]).to.equal(0x00);
+        expect(res[2]).to.equal(0x44);
+      });
+
+      it("ADC Indirect, X", function(){
+        asm.reset();
+        asm.compile("ADC ($44,X)");
+        let res = asm.result();
+        expect(res.length).to.equal(2);
+        expect(res[0]).to.equal(0x61);
+        expect(res[1]).to.equal(0x44);
+      });
+
+      it("ADC Indirect, Y", function(){
+        asm.reset();
+        asm.compile("ADC ($44), Y");
+        let res = asm.result();
+        expect(res.length).to.equal(2);
+        expect(res[0]).to.equal(0x71);
+        expect(res[1]).to.equal(0x44);
+      });
+      // -------------------------------------------------------------
+      it("AND Immediate");
+      it("AND Zero Page");
+      it("AND Zero Page, X");
+      it("AND Absolute");
+      it("AND Absolute, X");
+      it("AND Absolute, Y");
+      it("AND Indirect, X");
+      it("AND Indirect, Y");
+      // -------------------------------------------------------------
+      it("ASL Accumulator");
+      it("ASL Zero Page");
+      it("ASL Zero Page, X");
+      it("ASL Absolute");
+      it("ASL Absolute, X");
+      // -------------------------------------------------------------
+      it("BIT Zero Page");
+      it("BIT Absolute");
+      // -------------------------------------------------------------
+      it("BPL");
+      it("BMI");
+      it("BVC");
+      it("BVS");
+      it("BCC");
+      it("BCS");
+      it("BNE");
+      it("BEQ");
+      // -------------------------------------------------------------
+      it ("BRK", function(){
+        asm.reset();
+        let res = asm.compile("BRK").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x00);
+      });
+      // -------------------------------------------------------------
+      it("CMP Immediate");
+      it("CMP Zero Page");
+      it("CMP Zero Page, X");
+      it("CMP Absolute");
+      it("CMP Absolute, X");
+      it("CMP Absolute, Y");
+      it("CMP Indirect, X");
+      it("CMP Indirect, Y");
+      // -------------------------------------------------------------
+      it("CPX Immediate");
+      it("CPX Zero Page");
+      it("CPX Absolute");
+      // -------------------------------------------------------------
+      it("CPY Immediate");
+      it("CPY Zero Page");
+      it("CPY Absolute");
+      // -------------------------------------------------------------
+      it("DEC Zero Page");
+      it("DEC Zero Page, X");
+      it("DEC Absolute");
+      it("DEC Absolute, X");
+
+      // -------------------------------------------------------------
+      it("EOR Immediate");
+      it("EOR Zero Page");
+      it("EOR Zero Page, X");
+      it("EOR Absolute");
+      it("EOR Absolute, X");
+      it("EOR Absolute, Y");
+      it("EOR Indirect, X");
+      it("EOR Indirect, Y");
+
+      // -------------------------------------------------------------
+      it("CLC", function(){
+        asm.reset();
+        let res = asm.compile("CLC").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x18);
+      });
+
+      it("CLD", function(){
+        asm.reset();
+        let res = asm.compile("CLD").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0xD8);
+      });
+
+      it("CLI", function(){
+        asm.reset();
+        let res = asm.compile("CLI").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x58);
+      });
+
+      it("CLV", function(){
+        asm.reset();
+        let res = asm.compile("CLV").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0xB8);
+      });
+
+      it("SEC", function(){
+        asm.reset();
+        let res = asm.compile("SEC").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x38);
+      });
+
+      it("SED", function(){
+        asm.reset();
+        let res = asm.compile("SED").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0xF8);
+      });
+
+      it("SEI", function(){
+        asm.reset();
+        let res = asm.compile("SEI").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x78);
+      });
+
+      // -------------------------------------------------------------
+      it("INC Zero Page");
+      it("INC Zero Page, X");
+      it("INC Absolute");
+      it("INC Absolute, X");
+      // -------------------------------------------------------------
+      it("JMP Absolute");
+      it("JMP Indirect");
+      // -------------------------------------------------------------
+      it("JRS Absolute");
+      // -------------------------------------------------------------
+      it("LDA Immediate");
+      it("LDA Zero Page");
+      it("LDA Zero Page, X");
+      it("LDA Absolute");
+      it("LDA Absolute, X");
+      it("LDA Absolute, Y");
+      it("LDA Indirect, X");
+      it("LDA Indirect, Y");
+      // -------------------------------------------------------------
+      it("LDX Immediate");
+      it("LDX Zero Page");
+      it("LDX Zero Page, Y");
+      it("LDX Absolute");
+      it("LDX Absolute, Y");
+      // -------------------------------------------------------------
+      it("LDY Immediate");
+      it("LDY Zero Page");
+      it("LDY Zero Page, X");
+      it("LDY Absolute");
+      it("LDY Absolute, X");
+      // -------------------------------------------------------------
+      it("LSR Accumulator");
+      it("LSR Zero Page");
+      it("LSR Zero Page, X");
+      it("LSR Absolute");
+      it("LSR Absolute, X");
+      // -------------------------------------------------------------
+      it("NOP", function(){
+        asm.reset();
+        let res = asm.compile("NOP").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0xEA);
+      });
+
+      // -------------------------------------------------------------
+      it("ORA Immediate");
+      it("ORA Zero Page");
+      it("ORA Zero Page, X");
+      it("ORA Absolute");
+      it("ORA Absolute, X");
+      it("ORA Absolute, Y");
+      it("ORA Indirect, X");
+      it("ORA Indirect, Y");
+      // -------------------------------------------------------------
+      it("DEX", function(){
+        asm.reset();
+        let res = asm.compile("DEX").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0xCA);
+      });
+
+      it("DEY", function(){
+        asm.reset();
+        let res = asm.compile("DEY").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x88);
+      });
+
+      it("INX", function(){
+        asm.reset();
+        let res = asm.compile("INX").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0xE8);
+      });
+
+      it("INY", function(){
+        asm.reset();
+        let res = asm.compile("INY").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0xC8);
+      });
+
+      it("TAX", function(){
+        asm.reset();
+        let res = asm.compile("TAX").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0xAA);
+      });
+
+      it("TAY", function(){
+        asm.reset();
+        let res = asm.compile("TAY").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0xA8);
+      });
+
+      it("TXA", function(){
+        asm.reset();
+        let res = asm.compile("TXA").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x8A);
+      });
+
+      it("TYA", function(){
+        asm.reset();
+        let res = asm.compile("TYA").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x98);
+      });
+
+      // -------------------------------------------------------------
+      it("ROL Accumulator");
+      it("ROL Zero Page");
+      it("ROL Zero Page, X");
+      it("ROL Absolute");
+      it("ROL Absolute, X");
+      // -------------------------------------------------------------
+      it("ROR Accumulator");
+      it("ROR Zero Page");
+      it("ROR Zero Page, X");
+      it("ROR Absolute");
+      it("ROR Absolute, X");
+      // -------------------------------------------------------------
+      it("RTI", function(){
+        asm.reset();
+        let res = asm.compile("RTI").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x40);
+      });
+      it("RTS", function(){
+        asm.reset();
+        let res = asm.compile("RTS").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x60);
+      });
+
+      // -------------------------------------------------------------
+      it("SBC Immediate");
+      it("SBC Zero Page");
+      it("SBC Zero Page, X");
+      it("SBC Absolute");
+      it("SBC Absolute, X");
+      it("SBC Absolute, Y");
+      it("SBC Indirect, X");
+      it("SBC Indirect, Y");
+      // -------------------------------------------------------------
+      it("STA Zero Page");
+      it("STA Zero Page, X");
+      it("STA Absolute");
+      it("STA Absolute, X");
+      it("STA Absolute, Y");
+      it("STA Indirect, X");
+      it("STA Indirect, Y");
+      // -------------------------------------------------------------
+      it("PHA", function(){
+        asm.reset();
+        let res = asm.compile("PHA").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x48);
+      });
+
+      it("PHP", function(){
+        asm.reset();
+        let res = asm.compile("PHP").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x08);
+      });
+
+      it("PLA", function(){
+        asm.reset();
+        let res = asm.compile("PLA").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x68);
+      });
+
+      it("PLP", function(){
+        asm.reset();
+        let res = asm.compile("PLP").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x28);
+      });
+
+      it("TSX", function(){
+        asm.reset();
+        let res = asm.compile("TSX").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0xBA);
+      });
+
+      it("TXS", function(){
+        asm.reset();
+        let res = asm.compile("TXS").result();
+        expect(res.length).to.equal(1);
+        expect(res[0]).to.equal(0x9A);
+      });
+
+      // -------------------------------------------------------------
+      it("STX Zero Page");
+      it("STX Zero Page, Y");
+      it("STX Absolute");
+      // -------------------------------------------------------------
+      it("STY Zero Page");
+      it("STY Zero Page, X");
+      it("STY Absolute");
+    });
+  });
+
+  describe("Testing MOS6502 CPU...", function(){
+    it("Something here...");
+  });
+});