@asm80/core/test/asm-6502.js

Core ASM80 compiler / assembler

import { C6502 } from "../cpu/c6502.js";
import { Parser } from "../expression-parser.js";
import QUnit from "qunit"



QUnit.module("ASM-6502");

QUnit.test( "Namespace", function() {
	QUnit.assert.notEqual( C6502, null, "C6502 is defined" );
    QUnit.assert.equal( typeof(C6502), "object", "C6502 is an object" );
	QUnit.assert.equal( typeof(C6502.parseOpcode), "function", "C6502.parseOpcode defined" );
});

QUnit.test( "Invalid instruction", function() {
	s = {"opcode":"INVALID","params":["A","B"],"addr":0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p,null,"Error detected");
});

var vars = {"LOOP":0x1234,"SHORT":0x21,"_PC":0x0100};
var s = [], p;

QUnit.test( "Mode zpg $12", function() {
	s = {"opcode":"LDA",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xa5,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x12,"Expected value $12");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});
QUnit.test( "Mode zpg *short", function() {
	s = {"opcode":"LDA",params:["*short"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xa5,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x21,"Expected value for *short");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "Mode bad", function() {
	s = {"opcode":"LDA",params:[],addr:0x100,"lens":[],"bytes":0};
	QUnit.assert.throws(function(){
	p = C6502.parseOpcode(s);}, null, "Bad mode");
});


QUnit.test("STA Y,22", function() {
  QUnit.assert.throws(function(){
    vars = {"LOOP":0x1234,"SHORT":0x21,"NEAR":0x0105,"BEAR":0xf0,"_PC":0x0100};
    s = {"opcode":"STA","params":["Y","$22"],addr:"0x100",lens:[],"bytes":0};
    p = C6502.parseOpcode(s,vars);
    //p.lens[1](vars);
  });
});
/*
QUnit.test("STU 22", function() {
  QUnit.assert.throws(function(){
    vars = {"LOOP":0x1234,"SHORT":0x21,"NEAR":0x0105,"BEAR":0xf0,"_PC":0x0100};
    s = {"opcode":"STU","params":["$22"],addr:"0x100",lens:[],"bytes":0};
    p = C6502.parseOpcode(s,vars);
    //p.lens[1](vars);
  });
});
*/



QUnit.test( "SLO test, mode abs", function() {
	s = {"opcode":"SLO",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xf,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x1234,"Expected low byte of $1234");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "SLO test, mode abx", function() {
	s = {"opcode":"SLO",params:["$1234","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x1f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x1234,"Expected low byte of $1234");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "SLO test, mode aby", function() {
	s = {"opcode":"SLO",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x1b,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x1234,"Expected low byte of $1234");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "SLO test, mode zpg", function() {
	s = {"opcode":"SLO",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x12,"Expected value $12");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SLO test, mode zpx", function() {
	s = {"opcode":"SLO",params:["$12","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x17,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x12,"Expected value $12");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SLO test, mode ixz", function() {
	s = {"opcode":"SLO",params:["($12","X)"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s,vars,Parser);
	QUnit.assert.equal(p.lens[0],0x3,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x12,"Expected value $12");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SLO test, mode izy", function() {
	s = {"opcode":"SLO",params:["($12)","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars,Parser);
	QUnit.assert.equal(p.lens[0],0x13,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x12,"Expected value $12");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RLA test, mode abs", function() {
	s = {"opcode":"RLA",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x2f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "RLA test, mode abx", function() {
	s = {"opcode":"RLA",params:["$1234","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x3f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "RLA test, mode aby", function() {
	s = {"opcode":"RLA",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x3b,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "RLA test, mode zpg", function() {
	s = {"opcode":"RLA",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x27,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RLA test, mode zpx", function() {
	s = {"opcode":"RLA",params:["$12","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x37,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RLA test, mode ixz", function() {
	s = {"opcode":"RLA",params:["($12","X)"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x23,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RLA test, mode izy", function() {
	s = {"opcode":"RLA",params:["($12)","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x33,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.module("Additional 6502 function tests");

QUnit.test( "LDA #$23 - immediate mode", function() {
	s = {"opcode":"LDA",params:["#$23"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xa9,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x23,"Expected immediate value $23");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "LDA $1234 - absolute mode", function() {
	s = {"opcode":"LDA",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xad,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x1234,"Expected low byte $34");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "LDA $1234,X - absolute,X mode", function() {
	s = {"opcode":"LDA",params:["$1234","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xbd,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x1234,"Expected low byte $34");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "LDA $12,X - zero page,X mode", function() {
	s = {"opcode":"LDA",params:["$12","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xb5,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x12,"Expected value $12");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "LDA ($12,X) - indexed indirect mode", function() {
	s = {"opcode":"LDA",params:["($12","X)"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xa1,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x12,"Expected value $12");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "LDA ($12),Y - indirect indexed mode", function() {
	s = {"opcode":"LDA",params:["($12)","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xb1,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x12,"Expected value $12");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BEQ LOOP - relative mode", function() {
	s = {"opcode":"BEQ",params:["LOOP"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xf0,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x1132,"Expected relative offset to LOOP");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "LDA SHORT - auto zero page detection", function() {
	s = {"opcode":"LDA",params:["SHORT"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xa5,"Opcode OK - auto zero page");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.equal(outval1,0x21,"Expected SHORT value 0x21");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SRE test, mode abs", function() {
	s = {"opcode":"SRE",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x4f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "SRE test, mode abx", function() {
	s = {"opcode":"SRE",params:["$1234","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x5f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "SRE test, mode aby", function() {
	s = {"opcode":"SRE",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x5b,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "SRE test, mode zpg", function() {
	s = {"opcode":"SRE",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x47,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SRE test, mode zpx", function() {
	s = {"opcode":"SRE",params:["$12","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x57,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SRE test, mode ixz", function() {
	s = {"opcode":"SRE",params:["($12","X)"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x43,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SRE test, mode izy", function() {
	s = {"opcode":"SRE",params:["($12)","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x53,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RRA test, mode abs", function() {
	s = {"opcode":"RRA",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x6f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "RRA test, mode abx", function() {
	s = {"opcode":"RRA",params:["$1234","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x7f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "RRA test, mode aby", function() {
	s = {"opcode":"RRA",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x7b,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "RRA test, mode zpg", function() {
	s = {"opcode":"RRA",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x67,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RRA test, mode zpx", function() {
	s = {"opcode":"RRA",params:["$12","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x77,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RRA test, mode ixz", function() {
	s = {"opcode":"RRA",params:["($12","X)"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x63,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RRA test, mode izy", function() {
	s = {"opcode":"RRA",params:["($12)","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x73,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SAX test, mode abs", function() {
	s = {"opcode":"SAX",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x8f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "SAX test, mode zpg", function() {
	s = {"opcode":"SAX",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x87,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SAX test, mode zpy", function() {
	s = {"opcode":"SAX",params:["$12","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x97,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	let test = p.lens[1](vars);
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SAX test, mode ixz", function() {
	s = {"opcode":"SAX",params:["($12","X)"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x83,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "LAX test, mode imm", function() {
	s = {"opcode":"LAX",params:["#$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xab,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "LAX test, mode abs", function() {
	s = {"opcode":"LAX",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xaf,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "LAX test, mode aby", function() {
	s = {"opcode":"LAX",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xbf,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "LAX test, mode zpg", function() {
	s = {"opcode":"LAX",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xa7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "LAX test, mode zpy", function() {
	s = {"opcode":"LAX",params:["$12","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xb7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "LAX test, mode ixz", function() {
	s = {"opcode":"LAX",params:["($12","X)"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xa3,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "LAX test, mode izy", function() {
	s = {"opcode":"LAX",params:["($12)","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xb3,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "DCP test, mode abs", function() {
	s = {"opcode":"DCP",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xcf,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "DCP test, mode abx", function() {
	s = {"opcode":"DCP",params:["$1234","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xdf,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "DCP test, mode aby", function() {
	s = {"opcode":"DCP",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xdb,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "DCP test, mode zpg", function() {
	s = {"opcode":"DCP",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xc7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "DCP test, mode zpx", function() {
	s = {"opcode":"DCP",params:["$12","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xd7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "DCP test, mode ixz", function() {
	s = {"opcode":"DCP",params:["($12","X)"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xc3,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "DCP test, mode izy", function() {
	s = {"opcode":"DCP",params:["($12)","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xd3,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "ISC test, mode abs", function() {
	s = {"opcode":"ISC",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xef,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "ISC test, mode abx", function() {
	s = {"opcode":"ISC",params:["$1234","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xff,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "ISC test, mode aby", function() {
	s = {"opcode":"ISC",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xfb,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "ISC test, mode zpg", function() {
	s = {"opcode":"ISC",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xe7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "ISC test, mode zpx", function() {
	s = {"opcode":"ISC",params:["$12","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xf7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "ISC test, mode ixz", function() {
	s = {"opcode":"ISC",params:["($12","X)"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xe3,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "ISC test, mode izy", function() {
	s = {"opcode":"ISC",params:["($12)","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xf3,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "ANC test, mode imm", function() {
	s = {"opcode":"ANC",params:["#$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xb,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "ALR test, mode imm", function() {
	s = {"opcode":"ALR",params:["#$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x4b,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "ARR test, mode imm", function() {
	s = {"opcode":"ARR",params:["#$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x6b,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "XAA test, mode imm", function() {
	s = {"opcode":"XAA",params:["#$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x8b,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "AXS test, mode imm", function() {
	s = {"opcode":"AXS",params:["#$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xcb,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "AHX test, mode aby", function() {
	s = {"opcode":"AHX",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x9f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "AHX test, mode izy", function() {
	s = {"opcode":"AHX",params:["($12)","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x93,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SHY test, mode abx", function() {
	s = {"opcode":"SHY",params:["$1234","X"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x9c,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "SHX test, mode aby", function() {
	s = {"opcode":"SHX",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x9e,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "TAS test, mode aby", function() {
	s = {"opcode":"TAS",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x9b,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "LAS test, mode aby", function() {
	s = {"opcode":"LAS",params:["$1234","Y"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xbb,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "BRA test, mode rel", function() {
	s = {"opcode":"BRA",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s,vars,Parser);
	QUnit.assert.equal(p.lens[0],0x80,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	let test = p.lens[1](vars);
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "PHX test, mode imp", function() {
	s = {"opcode":"PHX","addr":0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xda,"Opcode OK");
	QUnit.assert.equal(p.bytes,1,"Length OK");
});

QUnit.test( "PHY test, mode imp", function() {
	s = {"opcode":"PHY","addr":0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x5a,"Opcode OK");
	QUnit.assert.equal(p.bytes,1,"Length OK");
});

QUnit.test( "PLX test, mode imp", function() {
	s = {"opcode":"PLX","addr":0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xfa,"Opcode OK");
	QUnit.assert.equal(p.bytes,1,"Length OK");
});

QUnit.test( "PLY test, mode imp", function() {
	s = {"opcode":"PLY","addr":0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x7a,"Opcode OK");
	QUnit.assert.equal(p.bytes,1,"Length OK");
});

QUnit.test( "RMB0 test, mode zpg", function() {
	s = {"opcode":"RMB0",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RMB1 test, mode zpg", function() {
	s = {"opcode":"RMB1",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x17,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RMB2 test, mode zpg", function() {
	s = {"opcode":"RMB2",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x27,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RMB3 test, mode zpg", function() {
	s = {"opcode":"RMB3",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x37,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RMB4 test, mode zpg", function() {
	s = {"opcode":"RMB4",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x47,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RMB5 test, mode zpg", function() {
	s = {"opcode":"RMB5",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x57,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RMB6 test, mode zpg", function() {
	s = {"opcode":"RMB6",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x67,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "RMB7 test, mode zpg", function() {
	s = {"opcode":"RMB7",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x77,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SMB0 test, mode zpg", function() {
	s = {"opcode":"SMB0",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x87,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SMB1 test, mode zpg", function() {
	s = {"opcode":"SMB1",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x97,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SMB2 test, mode zpg", function() {
	s = {"opcode":"SMB2",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xa7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SMB3 test, mode zpg", function() {
	s = {"opcode":"SMB3",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xb7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SMB4 test, mode zpg", function() {
	s = {"opcode":"SMB4",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xc7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SMB5 test, mode zpg", function() {
	s = {"opcode":"SMB5",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xd7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SMB6 test, mode zpg", function() {
	s = {"opcode":"SMB6",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xe7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "SMB7 test, mode zpg", function() {
	s = {"opcode":"SMB7",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xf7,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBR0 test, mode rel", function() {
	s = {"opcode":"BBR0",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xf,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBR1 test, mode rel", function() {
	s = {"opcode":"BBR1",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x1f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBR2 test, mode rel", function() {
	s = {"opcode":"BBR2",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x2f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBR3 test, mode rel", function() {
	s = {"opcode":"BBR3",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x3f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBR4 test, mode rel", function() {
	s = {"opcode":"BBR4",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x4f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBR5 test, mode rel", function() {
	s = {"opcode":"BBR5",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x5f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBR6 test, mode rel", function() {
	s = {"opcode":"BBR6",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x6f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBR7 test, mode rel", function() {
	s = {"opcode":"BBR7",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x7f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBS0 test, mode rel", function() {
	s = {"opcode":"BBS0",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x8f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBS1 test, mode rel", function() {
	s = {"opcode":"BBS1",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x9f,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBS2 test, mode rel", function() {
	s = {"opcode":"BBS2",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xaf,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBS3 test, mode rel", function() {
	s = {"opcode":"BBS3",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xbf,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBS4 test, mode rel", function() {
	s = {"opcode":"BBS4",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xcf,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBS5 test, mode rel", function() {
	s = {"opcode":"BBS5",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xdf,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBS6 test, mode rel", function() {
	s = {"opcode":"BBS6",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xef,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "BBS7 test, mode rel", function() {
	s = {"opcode":"BBS7",params:["$123"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xff,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "TRB test, mode abs", function() {
	s = {"opcode":"TRB",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x1c,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "TRB test, mode zpg", function() {
	s = {"opcode":"TRB",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x14,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "TSB test, mode abs", function() {
	s = {"opcode":"TSB",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0xc,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "TSB test, mode zpg", function() {
	s = {"opcode":"TSB",params:["$12"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x4,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,2,"Length OK");
});

QUnit.test( "STZ test, mode abs", function() {
	s = {"opcode":"STZ",params:["$1234"],addr:0x100,"lens":[],"bytes":0};
	p = C6502.parseOpcode(s, vars, Parser);
	QUnit.assert.equal(p.lens[0],0x9c,"Opcode OK");
	QUnit.assert.equal(typeof(p.lens[1]),"function","Opcode");
	const outval1 = p.lens[1](vars);
	QUnit.assert.ok(typeof outval1 === "number", "Function returns number");
	QUnit.assert.equal(p.bytes,3,"Length OK");
});

QUnit.test( "STZ test, mode abx", function(