F8/test/unit.src.MOS6502.assembler.spec.js

const expect = require('chai').expect;
const Assembler = require('../src/MOS6502/assembler.js');


describe("Testing MOS6502 Assembler...", function(){
  var asm = new 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(".define directive", function(){
      asm.compile(".define TAG $44");
      let vars = asm.variables;
      expect(vars).to.have.key('TAG');
      expect(vars['TAG']).to.equal(0x44);
    });

    it(".def directive (.define shorthand)", function(){
      asm.compile(".define TAG2 $55");
      let vars = asm.variables;
      expect(vars['TAG2']).to.exist;
      expect(vars['TAG2']).to.equal(0x55);
    });

    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(".bytes directive", function(){
      let res = asm.reset().compile(".BYTES $44, $55, $66, $77, b10110101, 128").result();
      expect(res.length).to.equal(6);
      expect(res[0]).to.equal(0x44);
      expect(res[1]).to.equal(0x55);
      expect(res[2]).to.equal(0x66);
      expect(res[3]).to.equal(0x77);
      expect(res[4]).to.equal(parseInt('10110101', 2));
      expect(res[5]).to.equal(128);
    });

    it(".byt directive (.bytes shorthand)", function(){
      let res = asm.reset().compile(".BYT $44, $55, $66").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x44);
      expect(res[1]).to.equal(0x55);
      expect(res[2]).to.equal(0x66);
    });

    it("Jump label before and after .byte directive", function(){
      asm.reset();
      let pc1 = asm.PC;
      asm.compile("bytes: .bytes $44, $55, $66, $77");
      let pc2 = asm.PC;
      asm.compile("loop: BNE loop");

      let jmp = asm.jumplabels;
      //expect(jmp).to.have.key('bytes');
      expect(jmp['bytes']).to.equal(pc1);
      //expect(jmp).to.have.key('loop');
      expect(jmp['loop']).to.equal(pc2);

      let res = asm.result();
      expect(res.length).to.equal(6);
      expect(res[0]).to.equal(0x44);
      expect(res[1]).to.equal(0x55);
      expect(res[2]).to.equal(0x66);
      expect(res[3]).to.equal(0x77);
      expect(res[4]).to.equal(0xD0);
      expect(res[5]).to.equal(0xFE);
    });

    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", function(){
      let res = asm.reset().compile("AND #$44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x29);
      expect(res[1]).to.equal(0x44);
    });

    it("AND Zero Page", function(){
      let res = asm.reset().compile("AND $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x25);
      expect(res[1]).to.equal(0x44);
    });

    it("AND Zero Page, X", function(){
      let res = asm.reset().compile("AND $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x35);
      expect(res[1]).to.equal(0x44);
    });

    it("AND Absolute", function(){
      let res = asm.reset().compile("AND $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x2D);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("AND Absolute, X", function(){
      let res = asm.reset().compile("AND $4400, X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x3D);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("AND Absolute, Y", function(){
      let res = asm.reset().compile("AND $4400, Y").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x39);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("AND Indirect, X", function(){
      let res = asm.reset().compile("AND ($44, X)").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x21);
      expect(res[1]).to.equal(0x44);
    });

    it("AND Indirect, Y", function(){
      let res = asm.reset().compile("AND ($44), Y").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x31);
      expect(res[1]).to.equal(0x44);
    });


    // -------------------------------------------------------------
    it("ASL Accumulator", function(){
      let res = asm.reset().compile("ASL A").result();
      expect(res.length).to.equal(1);
      expect(res[0]).to.equal(0x0A);
    });

    it("ASL Zero Page", function(){
      let res = asm.reset().compile("ASL $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x06);
      expect(res[1]).to.equal(0x44);
    });

    it("ASL Zero Page, X", function(){
      let res = asm.reset().compile("ASL $44, X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x16);
      expect(res[1]).to.equal(0x44);
    });

    it("ASL Absolute", function(){
      let res = asm.reset().compile("ASL $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x0E);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("ASL Absolute, X", function(){
      let res = asm.reset().compile("ASL $4400, X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x1E);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("BIT Zero Page", function(){
      let res = asm.reset().compile("BIT $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x24);
      expect(res[1]).to.equal(0x44);
    });

    it("BIT Absolute", function(){
      let res = asm.reset().compile("BIT $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x2C);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("BPL", function(){
      let res = asm.reset().compile("NOP\nNOP\nBPL $0000").result();
      expect(res.length).to.equal(4);
      expect(res[0]).to.equal(0xEA);
      expect(res[1]).to.equal(0xEA);
      expect(res[2]).to.equal(0x10);
      expect(res[3]).to.equal(0xFC);
    });

    it("BMI", function(){
      let res = asm.reset().compile("BMI $0003\nNOP\nNOP").result();
      expect(res.length).to.equal(4);
      expect(res[0]).to.equal(0x30);
      expect(res[1]).to.equal(0x02);
      expect(res[2]).to.equal(0xEA);
      expect(res[3]).to.equal(0xEA);
    });

    it("BVC", function(){
      let res = asm.reset().compile("BVC $0003\nNOP\nNOP").result();
      expect(res.length).to.equal(4);
      expect(res[0]).to.equal(0x50);
      expect(res[1]).to.equal(0x02);
      expect(res[2]).to.equal(0xEA);
      expect(res[3]).to.equal(0xEA);
    });

    it("BVS", function(){
      let res = asm.reset().compile("NOP\nNOP\nBVS $0000").result();
      expect(res.length).to.equal(4);
      expect(res[0]).to.equal(0xEA);
      expect(res[1]).to.equal(0xEA);
      expect(res[2]).to.equal(0x70);
      expect(res[3]).to.equal(0xFC);
    });

    it("BCC", function(){
      let res = asm.reset().compile("BCC $0003\nNOP\nNOP").result();
      expect(res.length).to.equal(4);
      expect(res[0]).to.equal(0x90);
      expect(res[1]).to.equal(0x02);
      expect(res[2]).to.equal(0xEA);
      expect(res[3]).to.equal(0xEA);
    });

    it("BCS", function(){
      let res = asm.reset().compile("NOP\nNOP\nBCS $0000").result();
      expect(res.length).to.equal(4);
      expect(res[0]).to.equal(0xEA);
      expect(res[1]).to.equal(0xEA);
      expect(res[2]).to.equal(0xB0);
      expect(res[3]).to.equal(0xFC);
    });

    it("BNE", function(){
      let res = asm.reset().compile("BNE $0003\nNOP\nNOP").result();
      expect(res.length).to.equal(4);
      expect(res[0]).to.equal(0xD0);
      expect(res[1]).to.equal(0x02);
      expect(res[2]).to.equal(0xEA);
      expect(res[3]).to.equal(0xEA);
    });

    it("BEQ", function(){
      let res = asm.reset().compile("NOP\nNOP\nBEQ $0000").result();
      expect(res.length).to.equal(4);
      expect(res[0]).to.equal(0xEA);
      expect(res[1]).to.equal(0xEA);
      expect(res[2]).to.equal(0xF0);
      expect(res[3]).to.equal(0xFC);
    });

    it("Branch Too Far Back", function(){
      expect(()=>{
        let asm2 = new Assembler(0x1000);
        let res = asm2.compile("BNE $0000").result();
      }).to.throw("Branch exceeds maximum number of bytes on program address 1001");
    });

    it("Branch Too Far Forward", function(){
      expect(()=>{
        let res = asm.reset().compile("BNE $00F0").result();
      }).to.throw("Branch exceeds maximum number of bytes on program address 01");
    });

    // -------------------------------------------------------------
    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", function(){
      let res = asm.reset().compile("CMP #$44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xC9);
      expect(res[1]).to.equal(0x44);
    });

    it("CMP Zero Page", function(){
      let res = asm.reset().compile("CMP $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xC5);
      expect(res[1]).to.equal(0x44);
    });

    it("CMP Zero Page, X", function(){
      let res = asm.reset().compile("CMP $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xD5);
      expect(res[1]).to.equal(0x44);
    });

    it("CMP Absolute", function(){
      let res = asm.reset().compile("CMP $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xCD);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("CMP Absolute, X", function(){
      let res = asm.reset().compile("CMP $4400,X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xDD);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("CMP Absolute, Y", function(){
      let res = asm.reset().compile("CMP $4400, Y").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xD9);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("CMP Indirect, X", function(){
      let res = asm.reset().compile("CMP ($44,X)").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xC1);
      expect(res[1]).to.equal(0x44);
    });

    it("CMP Indirect, Y", function(){
      let res = asm.reset().compile("CMP ($44),Y").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xD1);
      expect(res[1]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("CPX Immediate", function(){
      let res = asm.reset().compile("CPX #$44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xE0);
      expect(res[1]).to.equal(0x44);
    });

    it("CPX Zero Page", function(){
      let res = asm.reset().compile("CPX $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xE4);
      expect(res[1]).to.equal(0x44);
    });

    it("CPX Absolute", function(){
      let res = asm.reset().compile("CPX $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xEC);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("CPY Immediate", function(){
      let res = asm.reset().compile("CPY #$44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xC0);
      expect(res[1]).to.equal(0x44);
    });

    it("CPY Zero Page", function(){
      let res = asm.reset().compile("CPY $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xC4);
      expect(res[1]).to.equal(0x44);
    });

    it("CPY Absolute", function(){
      let res = asm.reset().compile("CPY $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xCC);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("DEC Zero Page", function(){
      let res = asm.reset().compile("DEC $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xC6);
      expect(res[1]).to.equal(0x44);
    });

    it("DEC Zero Page, X", function(){
      let res = asm.reset().compile("DEC $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xD6);
      expect(res[1]).to.equal(0x44);
    });

    it("DEC Absolute", function(){
      let res = asm.reset().compile("DEC $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xCE);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("DEC Absolute, X", function(){
      let res = asm.reset().compile("DEC $4400,X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xDE);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("EOR Immediate", function(){
      let res = asm.reset().compile("EOR #$44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x49);
      expect(res[1]).to.equal(0x44);
    });

    it("EOR Zero Page", function(){
      let res = asm.reset().compile("EOR $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x45);
      expect(res[1]).to.equal(0x44);
    });

    it("EOR Zero Page, X", function(){
      let res = asm.reset().compile("EOR $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x55);
      expect(res[1]).to.equal(0x44);
    });

    it("EOR Absolute", function(){
      let res = asm.reset().compile("EOR $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x4D);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("EOR Absolute, X", function(){
      let res = asm.reset().compile("EOR $4400, X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x5D);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("EOR Absolute, Y", function(){
      let res = asm.reset().compile("EOR $4400,Y").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x59);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("EOR Indirect, X", function(){
      let res = asm.reset().compile("EOR ($44,X)").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x41);
      expect(res[1]).to.equal(0x44);
    });

    it("EOR Indirect, Y", function(){
      let res = asm.reset().compile("EOR ($44),Y").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x51);
      expect(res[1]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    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", function(){
      let res = asm.reset().compile("INC $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xE6);
      expect(res[1]).to.equal(0x44);
    });

    it("INC Zero Page, X", function(){
      let res = asm.reset().compile("INC $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xF6);
      expect(res[1]).to.equal(0x44);
    });

    it("INC Absolute", function(){
      let res = asm.reset().compile("INC $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xEE);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("INC Absolute, X", function(){
      let res = asm.reset().compile("INC $4400,X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xFE);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("JMP Absolute", function(){
      let res = asm.reset().compile("JMP $2134").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x4C);
      expect(res[1]).to.equal(0x34);
      expect(res[2]).to.equal(0x21);
    });

    it("JMP Indirect", function(){
      let res = asm.reset().compile("JMP ($2134)").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x6C);
      expect(res[1]).to.equal(0x34);
      expect(res[2]).to.equal(0x21);
    });

    // -------------------------------------------------------------
    it("JSR Absolute", function(){
      let res = asm.reset().compile("JSR $5122").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x20);
      expect(res[1]).to.equal(0x22);
      expect(res[2]).to.equal(0x51);
    });
    // -------------------------------------------------------------
    it("LDA Immediate", function(){
      let res = asm.reset().compile("LDA #$44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xA9);
      expect(res[1]).to.equal(0x44);
    });

    it("LDA Zero Page", function(){
      let res = asm.reset().compile("LDA $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xA5);
      expect(res[1]).to.equal(0x44);
    });

    it("LDA Zero Page, X", function(){
      let res = asm.reset().compile("LDA $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xB5);
      expect(res[1]).to.equal(0x44);
    });

    it("LDA Absolute", function(){
      let res = asm.reset().compile("LDA $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xAD);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("LDA Absolute, X", function(){
      let res = asm.reset().compile("LDA $4400,X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xBD);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("LDA Absolute, Y", function(){
      let res = asm.reset().compile("LDA $4400, Y").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xB9);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("LDA Indirect, X", function(){
      let res = asm.reset().compile("LDA ($44,X)").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xA1);
      expect(res[1]).to.equal(0x44);
    });

    it("LDA Indirect, Y", function(){
      let res = asm.reset().compile("LDA ($44),Y").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xB1);
      expect(res[1]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("LDX Immediate", function(){
      let res = asm.reset().compile("LDX #$44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xA2);
      expect(res[1]).to.equal(0x44);
    });

    it("LDX Zero Page", function(){
      let res = asm.reset().compile("LDX $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xA6);
      expect(res[1]).to.equal(0x44);
    });

    it("LDX Zero Page, Y", function(){
      let res = asm.reset().compile("LDX $44,Y").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xB6);
      expect(res[1]).to.equal(0x44);
    });

    it("LDX Absolute", function(){
      let res = asm.reset().compile("LDX $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xAE);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("LDX Absolute, Y", function(){
      let res = asm.reset().compile("LDX $4400,Y").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xBE);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("LDY Immediate", function(){
      let res = asm.reset().compile("LDY #$44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xA0);
      expect(res[1]).to.equal(0x44);
    });

    it("LDY Zero Page", function(){
      let res = asm.reset().compile("LDY $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xA4);
      expect(res[1]).to.equal(0x44);
    });

    it("LDY Zero Page, X", function(){
      let res = asm.reset().compile("LDY $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xB4);
      expect(res[1]).to.equal(0x44);
    });

    it("LDY Absolute", function(){
      let res = asm.reset().compile("LDY $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xAC);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("LDY Absolute, X", function(){
      let res = asm.reset().compile("LDY $4400,X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xBC);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("LSR Accumulator", function(){
      let res = asm.reset().compile("LSR A").result();
      expect(res.length).to.equal(1);
      expect(res[0]).to.equal(0x4A);
    });

    it("LSR Zero Page", function(){
      let res = asm.reset().compile("LSR $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x46);
      expect(res[1]).to.equal(0x44);
    });

    it("LSR Zero Page, X", function(){
      let res = asm.reset().compile("LSR $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x56);
      expect(res[1]).to.equal(0x44);
    });

    it("LSR Absolute", function(){
      let res = asm.reset().compile("LSR $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x4E);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("LSR Absolute, X", function(){
      let res = asm.reset().compile("LSR $4400, X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x5E);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    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", function(){
      let res = asm.reset().compile("ORA #$44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x09);
      expect(res[1]).to.equal(0x44);
    });

    it("ORA Zero Page", function(){
      let res = asm.reset().compile("ORA $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x05);
      expect(res[1]).to.equal(0x44);
    });

    it("ORA Zero Page, X", function(){
      let res = asm.reset().compile("ORA $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x15);
      expect(res[1]).to.equal(0x44);
    });

    it("ORA Absolute", function(){
      let res = asm.reset().compile("ORA $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x0D);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("ORA Absolute, X", function(){
      let res = asm.reset().compile("ORA $4400,X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x1D);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("ORA Absolute, Y", function(){
      let res = asm.reset().compile("ORA $4400,Y").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x19);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("ORA Indirect, X", function(){
      let res = asm.reset().compile("ORA ($44,X)").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x01);
      expect(res[1]).to.equal(0x44);
    });

    it("ORA Indirect, Y", function(){
      let res = asm.reset().compile("ORA ($44), Y").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x11);
      expect(res[1]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    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", function(){
      let res = asm.reset().compile("ROL A").result();
      expect(res.length).to.equal(1);
      expect(res[0]).to.equal(0x2A);
    });

    it("ROL Zero Page", function(){
      let res = asm.reset().compile("ROL $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x26);
      expect(res[1]).to.equal(0x44);
    });

    it("ROL Zero Page, X", function(){
      let res = asm.reset().compile("ROL $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x36);
      expect(res[1]).to.equal(0x44);
    });

    it("ROL Absolute", function(){
      let res = asm.reset().compile("ROL $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x2E);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("ROL Absolute, X", function(){
      let res = asm.reset().compile("ROL $4400,X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x3E);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("ROR Accumulator", function(){
      let res = asm.reset().compile("ROR A").result();
      expect(res.length).to.equal(1);
      expect(res[0]).to.equal(0x6A);
    });

    it("ROR Zero Page", function(){
      let res = asm.reset().compile("ROR $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x66);
      expect(res[1]).to.equal(0x44);
    });

    it("ROR Zero Page, X", function(){
      let res = asm.reset().compile("ROR $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x76);
      expect(res[1]).to.equal(0x44);
    });

    it("ROR Absolute", function(){
      let res = asm.reset().compile("ROR $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x6E);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("ROR Absolute, X", function(){
      let res = asm.reset().compile("ROR $4400,X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x7E);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    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", function(){
      let res = asm.reset().compile("SBC #$44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xE9);
      expect(res[1]).to.equal(0x44);
    });

    it("SBC Zero Page", function(){
      let res = asm.reset().compile("SBC $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xE5);
      expect(res[1]).to.equal(0x44);
    });

    it("SBC Zero Page, X", function(){
      let res = asm.reset().compile("SBC $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xF5);
      expect(res[1]).to.equal(0x44);
    });

    it("SBC Absolute", function(){
      let res = asm.reset().compile("SBC $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xED);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("SBC Absolute, X", function(){
      let res = asm.reset().compile("SBC $4400,X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xFD);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("SBC Absolute, Y", function(){
      let res = asm.reset().compile("SBC $4400,Y").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0xF9);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("SBC Indirect, X", function(){
      let res = asm.reset().compile("SBC ($44,X)").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xE1);
      expect(res[1]).to.equal(0x44);
    });

    it("SBC Indirect, Y", function(){
      let res = asm.reset().compile("SBC ($44),Y").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0xF1);
      expect(res[1]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("STA Zero Page", function(){
      let res = asm.reset().compile("STA $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x85);
      expect(res[1]).to.equal(0x44);
    });

    it("STA Zero Page, X", function(){
      let res = asm.reset().compile("STA $44,X").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x95);
      expect(res[1]).to.equal(0x44);
    });

    it("STA Absolute", function(){
      let res = asm.reset().compile("STA $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x8D);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("STA Absolute, X", function(){
      let res = asm.reset().compile("STA $4400,X").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x9D);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("STA Absolute, Y", function(){
      let res = asm.reset().compile("STA $4400,Y").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x99);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    it("STA Indirect, X", function(){
      let res = asm.reset().compile("STA ($44,X)").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x81);
      expect(res[1]).to.equal(0x44);
    });

    it("STA Indirect, Y", function(){
      let res = asm.reset().compile("STA ($44),Y").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x91);
      expect(res[1]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    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", function(){
      let res = asm.reset().compile("STX $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x86);
      expect(res[1]).to.equal(0x44);
    });

    it("STX Zero Page, Y", function(){
      let res = asm.reset().compile("STX $44, Y").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x96);
      expect(res[1]).to.equal(0x44);
    });

    it("STX Absolute", function(){
      let res = asm.reset().compile("STX $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x8E);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // -------------------------------------------------------------
    it("STY Zero Page", function(){
      let res = asm.reset().compile("STY $44").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x84);
      expect(res[1]).to.equal(0x44);
    });

    it("STY Zero Page, X", function(){
      let res = asm.reset().compile("sty $44,x").result();
      expect(res.length).to.equal(2);
      expect(res[0]).to.equal(0x94);
      expect(res[1]).to.equal(0x44);
    });

    it("STY Absolute", function(){
      let res = asm.reset().compile("STY $4400").result();
      expect(res.length).to.equal(3);
      expect(res[0]).to.equal(0x8C);
      expect(res[1]).to.equal(0x00);
      expect(res[2]).to.equal(0x44);
    });

    // ------------------------------------------------------------- 
  });
});