nes-emu/cpu/addressings/specs/basic.spec.js

A NES emulator

"use strict";

var _2 = _interopRequireDefault(require(".."));
var _getValue = _interopRequireDefault(require("../_getValue"));
var _createTestContext = _interopRequireDefault(require("../../../helpers/createTestContext"));
var _helpers = require("../../../helpers");
var _lodash = _interopRequireDefault(require("lodash"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const should = require("chai").Should();
describe("addressings", () => {
  let cpu, memory, context;
  beforeEach(() => {
    ({
      cpu,
      memory,
      context
    } = (0, _createTestContext.default)());
  });
  it("getValue method", () => {
    memory.writeAt(0x0765, 123);
    const addressingMock = {
      getAddress: () => 0x0765,
      getValue: _getValue.default
    };
    addressingMock.getValue(context).should.equal(123);
  });
  describe("implicit", () => {
    it("returns null or an error", () => {
      (() => _2.default.IMPLICIT.getValue(context)).should.throw("The IMPLICIT addressing mode only supports the `getAddress` method (and it always returns null)");
      should.not.exist(_2.default.IMPLICIT.getAddress(context));
    });
  });
  describe("immediate", () => {
    it("returns the same value", () => {
      (() => _2.default.IMMEDIATE.getAddress(context, 120)).should.throw("The IMMEDIATE addressing mode only supports the `getValue` method");
      _2.default.IMMEDIATE.getValue(context, 120).should.equal(120);
    });
  });
  describe("absolute", () => {
    it("returns the same address", () => {
      _2.default.ABSOLUTE.getAddress(context, 0xfe8d).should.equal(0xfe8d);
    });
  });
  describe("zeroPage", () => {
    it("returns the same address", () => {
      _2.default.ZERO_PAGE.getAddress(context, 120).should.equal(120);
    });
  });
  describe("indirect", () => {
    it("dereferences the address", () => {
      memory.writeAt(130, 0x12);
      memory.writeAt(131, 0xfe);
      _2.default.INDIRECT.getAddress(context, 130).should.equal(0xfe12);
    });
    it("emulates the page boundary bug", () => {
      memory.writeAt(0x04ff, 0x12);
      memory.writeAt(0x0400, 0xcd);
      _2.default.INDIRECT.getAddress(context, 0x04ff).should.equal(0xcd12);
    });
  });
  describe("relative", () => {
    it("returns an address based on the current pc + offset", () => {
      cpu.pc.value = 0xfe10;
      _2.default.RELATIVE.getAddress(context, 4).should.equal(0xfe14);
      _2.default.RELATIVE.getAddress(context, _helpers.Byte.toSignedByte(-10)).should.equal(0xfe06);
    });
    describe("when the operation can take extra cycles", () => {
      it("adds two cycles if a page-crossed event occurs", () => {
        cpu.pc.value = 0xfafe;
        _2.default.RELATIVE.getAddress(context, 20, true);
        cpu.extraCycles.should.equal(2);
      });
      it("doesnt add any cycles if no page-crossed event occurs", () => {
        cpu.pc.value = 0xfe10;
        _2.default.RELATIVE.getAddress(context, 4, true);
        cpu.extraCycles.should.equal(0);
      });
    });
  });
  describe("accumulator", () => {
    it("returns the A register", () => {
      (() => _2.default.ACCUMULATOR.getValue(context, 120)).should.throw("The ACCUMULATOR addressing mode only supports the `getAddress` method");
      cpu.registers.a.value = 135;
      _2.default.ACCUMULATOR.getAddress(context).value.should.equal(135);
    });
  });
});