ObsidianBlk
/
F8
Seguir 1
Destacar 0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 0 Wiki Actividad
Fantasy 8Bit system (F8), is a fantasy 8bit console and a set of libraries for creating fantasy 8bit consoles.
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
77 Commits
1 Rama
Árbol: 124d9d4ff3
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde '124d9d4ff3'
${ noResults }
F8/test/unit.src.memory.memory.spec.js

499 líneas
15KB
Original Blame Histórico 

  1. const expect = require('chai').expect;

  2. const sinon = require('sinon');

  3. const Mem = require('../src/memory');

  4. 

  5. describe("Testing Memory Module", function(){

  6.   describe("Core Memory Classes...", function(){

  7.     describe("ROM Class", function(){

  8.       var m1 = new Mem.Memory.ROM(1);

  9.       var m2 = new Mem.Memory.ROM(4);

  10. 

  11.       it("Bytes match 256 byte page sizes", function(){

  12.         expect(m1.size).to.equal(256);

  13.         expect(m2.size).to.equal(1024);

  14.       });

  15. 

  16.       it("Loading Bytes", function(){

  17.         m1.load(0x80, [0x10, 0x44, 0xAB, 0x11, 0x9C]);

  18.         expect(m1.__map[0x80]).to.equal(0x10);

  19.         expect(m1.__map[0x81]).to.equal(0x44);

  20.         expect(m1.__map[0x82]).to.equal(0xAB);

  21.         expect(m1.__map[0x83]).to.equal(0x11);

  22.         expect(m1.__map[0x84]).to.equal(0x9C);

  23. 

  24.         m2.load(0x0100, [0x88, 0x77, 0x66, 0x55]);

  25.         m2.load(0x0200, [0xAA, 0xBB, 0xCC, 0xDD]);

  26.         expect(m2.__map[0x0100]).to.equal(0x88);

  27.         expect(m2.__map[0x0101]).to.equal(0x77);

  28.         expect(m2.__map[0x0102]).to.equal(0x66);

  29.         expect(m2.__map[0x0103]).to.equal(0x55);

  30. 

  31.         expect(m2.__map[0x0200]).to.equal(0xAA);

  32.         expect(m2.__map[0x0201]).to.equal(0xBB);

  33.         expect(m2.__map[0x0202]).to.equal(0xCC);

  34.         expect(m2.__map[0x0203]).to.equal(0xDD);

  35.       });

  36. 

  37.       it("Read Check", function(){

  38.         expect(m1.read(0x81)).to.equal(0x44);

  39.         expect(m1.address).to.equal(0x81);

  40.         expect(m1.read(0x84)).to.equal(0x9C);

  41.         expect(m1.address).to.equal(0x84);

  42. 

  43.         expect(m2.read(0x0102)).to.equal(0x66);

  44.         expect(m2.address).to.equal(0x0102);

  45.         expect(m2.read(0x0203)).to.equal(0xDD);

  46.         expect(m2.address).to.equal(0x0203);

  47.       });

  48. 

  49.       it("Address Within Memory Bounds", function(){

  50.         m1.address = 0x0100;

  51.         expect(m1.address).to.equal(0xFF);

  52.         m2.address = -1;

  53.         expect(m2.address).to.equal(0x00);

  54.         m2.address = 0x0400;

  55.         expect(m2.address).to.equal(0x03FF);

  56.       });

  57. 

  58.       it("Set Address / Get Byte", function(){

  59.         m1.address = 0x82;

  60.         expect(m1.byte).to.equal(0xAB);

  61.         m1.address = 0x83;

  62.         expect(m1.byte).to.equal(0x11);

  63. 

  64.         m2.address = 0x0101;

  65.         expect(m2.byte).to.equal(0x77);

  66.         m2.address = 0x0202;

  67.         expect(m2.byte).to.equal(0xCC);

  68.       });

  69. 

  70.       it("Address Read Callback", function(){

  71.         var cb = sinon.fake();

  72.         m2.onAddressRead(0x0100, cb);

  73.         m2.read(0x0100);

  74.         m2.read(0x0201);

  75.         m2.address = 0x0101;

  76.         m2.byte;

  77.         m2.address = 0x0100;

  78.         m2.byte;

  79.         expect(cb.callCount).to.equal(2);

  80.       });

  81. 

  82.       it("Peek", function(){

  83.         var cb = sinon.fake();

  84.         m2.onAddressRead(0x0101, cb);

  85.         expect(m2.peek(0x0101)).to.equal(0x77);

  86.         expect(cb.callCount).to.equal(0);

  87.         expect(m2.read(0x0101)).to.equal(0x77);

  88.         expect(cb.callCount).to.equal(1);

  89.         m2.peek(0x0101);

  90.         expect(cb.callCount).to.equal(1);

  91.       });

  92. 

  93.       it("Clear Page", function(){

  94.         m2.clearPage(2);

  95.         expect(m2.read(0x0200)).to.equal(0x00);

  96.         expect(m2.read(0x0201)).to.equal(0x00);

  97.         expect(m2.read(0x0202)).to.equal(0x00);

  98.         expect(m2.read(0x0203)).to.equal(0x00);

  99.       });

  100. 

  101.       it("Clear", function(){

  102.         m1.clear();

  103.         expect(m1.read(0x80)).to.equal(0x00);

  104.         expect(m1.read(0x81)).to.equal(0x00);

  105.         expect(m1.read(0x82)).to.equal(0x00);

  106.         expect(m1.read(0x83)).to.equal(0x00);

  107.       });

  108.     });

  109. 

  110.     describe("RAM Class", function(){

  111.       var m1 = new Mem.Memory.RAM(1);

  112.       var m2 = new Mem.Memory.RAM(4);

  113. 

  114.       it("Bytes match 256 byte page sizes", function(){

  115.         expect(m1.size).to.equal(256);

  116.         expect(m2.size).to.equal(1024);

  117.       });

  118. 

  119.       it("Loading Bytes", function(){

  120.         m1.load(0x80, [0x10, 0x44, 0xAB, 0x11, 0x9C]);

  121.         expect(m1.__map[0x80]).to.equal(0x10);

  122.         expect(m1.__map[0x81]).to.equal(0x44);

  123.         expect(m1.__map[0x82]).to.equal(0xAB);

  124.         expect(m1.__map[0x83]).to.equal(0x11);

  125.         expect(m1.__map[0x84]).to.equal(0x9C);

  126. 

  127.         m2.load(0x0100, [0x88, 0x77, 0x66, 0x55]);

  128.         m2.load(0x0200, [0xAA, 0xBB, 0xCC, 0xDD]);

  129.         expect(m2.__map[0x0100]).to.equal(0x88);

  130.         expect(m2.__map[0x0101]).to.equal(0x77);

  131.         expect(m2.__map[0x0102]).to.equal(0x66);

  132.         expect(m2.__map[0x0103]).to.equal(0x55);

  133. 

  134.         expect(m2.__map[0x0200]).to.equal(0xAA);

  135.         expect(m2.__map[0x0201]).to.equal(0xBB);

  136.         expect(m2.__map[0x0202]).to.equal(0xCC);

  137.         expect(m2.__map[0x0203]).to.equal(0xDD);

  138.       });

  139. 

  140.       it("Read Check", function(){

  141.         expect(m1.read(0x81)).to.equal(0x44);

  142.         expect(m1.address).to.equal(0x81);

  143.         expect(m1.read(0x84)).to.equal(0x9C);

  144.         expect(m1.address).to.equal(0x84);

  145. 

  146.         expect(m2.read(0x0102)).to.equal(0x66);

  147.         expect(m2.address).to.equal(0x0102);

  148.         expect(m2.read(0x0203)).to.equal(0xDD);

  149.         expect(m2.address).to.equal(0x0203);

  150.       });

  151. 

  152.       it("Write Check", function(){

  153.         expect(m1.read(0x85)).to.equal(0x00);

  154.         m1.write(0x85, 0x12);

  155.         expect(m1.read(0x85)).to.equal(0x12);

  156.         m1.write(0x85, 0xDC);

  157.         expect(m1.byte).to.equal(0xDC);

  158.       });

  159. 

  160.       it("Set Address / Get Byte", function(){

  161.         m1.address = 0x82;

  162.         expect(m1.byte).to.equal(0xAB);

  163.         m1.address = 0x83;

  164.         expect(m1.byte).to.equal(0x11);

  165. 

  166.         m2.address = 0x0101;

  167.         expect(m2.byte).to.equal(0x77);

  168.         m2.address = 0x0202;

  169.         expect(m2.byte).to.equal(0xCC);

  170.       });

  171. 

  172.       it("Set Address / Set Byte", function(){

  173.         m1.address = 0x86;

  174.         m1.byte = 0xFE;

  175.         m1.address = 0x87;

  176.         m1.byte = 0xEF;

  177.         expect(m1.read(0x86)).to.equal(0xFE);

  178.         expect(m1.read(0x87)).to.equal(0xEF);

  179.       });

  180. 

  181.       it("Address Within Memory Bounds", function(){

  182.         m1.address = 0x0100;

  183.         expect(m1.address).to.equal(0xFF);

  184.         m2.address = -1;

  185.         expect(m2.address).to.equal(0x00);

  186.         m2.address = 0x0400;

  187.         expect(m2.address).to.equal(0x03FF);

  188.       });

  189. 

  190.       it("Address Read Callback", function(){

  191.         var cb = sinon.fake();

  192.         m2.onAddressRead(0x0100, cb);

  193.         m2.read(0x0100);

  194.         m2.read(0x0201);

  195.         m2.address = 0x0101;

  196.         m2.byte;

  197.         m2.address = 0x0100;

  198.         m2.byte;

  199.         expect(cb.callCount).to.equal(2);

  200.       });

  201. 

  202.       it("Address Write Callback", function(){

  203.         var cb = sinon.fake();

  204.         m1.onAddressWrite(0x86, cb);

  205.         m1.write(0x86, 0x12);

  206.         expect(cb.lastArg).to.equal(0x12);

  207.         m1.write(0x86, 0x22);

  208.         expect(cb.lastArg).to.equal(0x22);

  209.         expect(cb.callCount).to.equal(2);

  210.       });

  211. 

  212.       it("Peek", function(){

  213.         var cb = sinon.fake();

  214.         m2.onAddressRead(0x0101, cb);

  215.         expect(m2.peek(0x0101)).to.equal(0x77);

  216.         expect(cb.callCount).to.equal(0);

  217.         expect(m2.read(0x0101)).to.equal(0x77);

  218.         expect(cb.callCount).to.equal(1);

  219.         m2.peek(0x0101);

  220.         expect(cb.callCount).to.equal(1);

  221.       });

  222. 

  223.       it("Poke", function(){

  224.         var cb = sinon.fake();

  225.         m2.onAddressWrite(0x0130, cb);

  226.         m2.poke(0x0130, 0x42);

  227.         expect(cb.callCount).to.equal(0);

  228.         expect(m2.peek(0x0130)).to.equal(0x42);

  229.         m2.write(0x0130, 0x46);

  230.         expect(cb.callCount).to.equal(1);

  231.         expect(m2.peek(0x0130)).to.equal(0x46);

  232.         m2.poke(0x0130, 0x42);

  233.         expect(cb.callCount).to.equal(1);

  234.       });

  235. 

  236.       it("Clear Page", function(){

  237.         m2.clearPage(2);

  238.         expect(m2.read(0x0200)).to.equal(0x00);

  239.         expect(m2.read(0x0201)).to.equal(0x00);

  240.         expect(m2.read(0x0202)).to.equal(0x00);

  241.         expect(m2.read(0x0203)).to.equal(0x00);

  242.       });

  243. 

  244.       it("Clear", function(){

  245.         m1.clear();

  246.         expect(m1.read(0x80)).to.equal(0x00);

  247.         expect(m1.read(0x81)).to.equal(0x00);

  248.         expect(m1.read(0x82)).to.equal(0x00);

  249.         expect(m1.read(0x83)).to.equal(0x00);

  250.       });

  251.     });

  252. 

  253.     describe("Shadow Class", function(){

  254.       var sm = new Mem.Memory.Shadow(1, 4);

  255. 

  256.       it("Bytes Match 256 Size", function(){

  257.         expect(sm.size).to.equal(256);

  258.       });

  259. 

  260.       it("Load Bytes", function(){

  261.         var stored = sm.load(0, [0x10, 0x20, 0x30, 0x40, 0x50]);

  262.         expect(stored).to.equal(4);

  263.         expect(sm.__map[0]).to.equal(0x10);

  264.         expect(sm.__map[1]).to.equal(0x20);

  265.         expect(sm.__map[2]).to.equal(0x30);

  266.         expect(sm.__map[3]).to.equal(0x40);

  267.       });

  268. 

  269.       it("Read Check", function(){

  270.         expect(sm.read(0x01)).to.equal(0x20);

  271.         expect(sm.read(0x05)).to.equal(0x20);

  272.         expect(sm.read(0x09)).to.equal(0x20);

  273.         expect(sm.read(0x0D)).to.equal(0x20);

  274.       });

  275. 

  276.       it("Write Check", function(){

  277.         sm.write(0x01, 0x11);

  278.         expect(sm.read(0x01)).to.equal(0x11);

  279.         expect(sm.read(0x05)).to.equal(0x11);

  280.         sm.write(0x05, 0x12);

  281.         expect(sm.read(0x05)).to.equal(0x11);

  282.       });

  283. 

  284.       it("Set Address / Get Byte", function(){

  285.         sm.address = 0x02;

  286.         expect(sm.byte).to.equal(0x30);

  287.         sm.address = 0x03;

  288.         expect(sm.byte).to.equal(0x40);

  289.         sm.address = 0x04;

  290.         expect(sm.byte).to.equal(0x10);

  291.         sm.address = 0x05;

  292.         expect(sm.byte).to.equal(0x11);

  293.       });

  294. 

  295.       it("Set Address / Set Byte", function(){

  296.         sm.address = 0x02;

  297.         sm.byte = 0x31;

  298.         expect(sm.byte).to.equal(0x31);

  299.         sm.address = 0x06;

  300.         expect(sm.byte).to.equal(0x31);

  301.         sm.byte = 0x32;

  302.         expect(sm.byte).to.equal(0x31);

  303.       });

  304. 

  305.       it("Address Within Memory Bounds", function(){

  306.         sm.address = 0x0100;

  307.         expect(sm.address).to.equal(0xFF);

  308.         sm.address = -1;

  309.         expect(sm.address).to.equal(0x00);

  310.       });

  311. 

  312.       it("Address Read Callback", function(){

  313.         var cb1 = sinon.fake();

  314.         var cb2 = sinon.fake();

  315.         sm.onAddressRead(0x01, cb1);

  316.         sm.onAddressRead(0x05, cb2);

  317.         sm.read(0x01);

  318.         expect(cb1.callCount).to.equal(1);

  319.         expect(cb2.callCount).to.equal(0);

  320.         sm.read(0x05);

  321.         expect(cb1.callCount).to.equal(1);

  322.         expect(cb2.callCount).to.equal(1);

  323.       });

  324. 

  325.       it("Address Write Callback", function(){

  326.         var cb1 = sinon.fake();

  327.         var cb2 = sinon.fake();

  328.         sm.onAddressWrite(0x01, cb1);

  329.         sm.write(0x01, 0x21);

  330.         expect(cb1.callCount).to.equal(1);

  331.         expect(cb1.lastArg).to.equal(0x21);

  332.         sm.onAddressWrite(0x05, cb2);

  333.         sm.write(0x05, 0x22);

  334.         expect(cb2.callCount).to.equal(0);

  335.         sm.write(0x01, 0x22);

  336.         expect(cb2.callCount).to.equal(1);

  337.         expect(cb2.lastArg).to.equal(0x22);

  338.         expect(cb1.callCount).to.equal(2);

  339.         expect(cb1.lastArg).to.equal(0x22);

  340.       });

  341. 

  342.       it("Peek");

  343.       it("Poke");

  344. 

  345.       it("Clear Page", function(){

  346.         sm.clearPage(0);

  347.         expect(sm.read(0x00)).to.equal(0x00);

  348.         expect(sm.read(0x01)).to.equal(0x00);

  349.         expect(sm.read(0x05)).to.equal(0x00);

  350.       });

  351. 

  352.       it("Clear", function(){

  353.         sm.load(0, [0x10, 0x20, 0x30, 0x40]);

  354.         sm.clear();

  355.         expect(sm.read(0x00)).to.equal(0x00);

  356.         expect(sm.read(0x01)).to.equal(0x00);

  357.         expect(sm.read(0x05)).to.equal(0x00);

  358.       });

  359.     });

  360.   });

  361. 

  362. 

  363.   describe("Memory Management Controller (MMC) Class", function(){

  364.     var mmc = new Mem.MMC();

  365.     var rcb = sinon.fake();

  366.     var wcb = sinon.fake();

  367.     let m1 = new Mem.Memory.RAM(1);

  368.     m1.onAddressRead(0x31, rcb);

  369.     m1.onAddressWrite(0x31, wcb);

  370.     mmc.connectMemory(m1);

  371.     mmc.connectMemory(new Mem.Memory.RAM(2));

  372.     mmc.connectMemory(new Mem.Memory.RAM(1));

  373. 

  374.     it("Reports 4 pages", function(){

  375.       expect(mmc.pages).to.equal(4);

  376.     });

  377. 

  378.     it("Bytes match 4 pages", function(){

  379.       expect(mmc.size).to.equal(1024);

  380.     });

  381. 

  382.     it("Load / Read Check", function(){

  383.       mmc.load(0, [0x01, 0x02, 0x03, 0x04]);

  384.       mmc.load(0x0200, [0x11, 0x22, 0x33, 0x44]);

  385.       mmc.load(0x0300, [0xAA, 0xBB, 0xCC, 0xDD]);

  386.       mmc.load(0xFE, [0x41, 0x42, 0x43, 0x44]);

  387. 

  388.       expect(mmc.read(0x01)).to.equal(0x02);

  389.       expect(mmc.read(0x0202)).to.equal(0x33);

  390.       expect(mmc.read(0x0303)).to.equal(0xDD);

  391.       expect(mmc.read(0xFF)).to.equal(0x42);

  392.       expect(mmc.read(0x0101)).to.equal(0x44);

  393.     });

  394. 

  395.     it("Write check", function(){

  396.       mmc.write(0x02, 0x06);

  397.       expect(mmc.read(0x02)).to.equal(0x06);

  398.       mmc.write(0x0115, 0x15);

  399.       expect(mmc.read(0x0115)).to.equal(0x15);

  400.       mmc.write(0x0207, 0x07);

  401.       expect(mmc.read(0x0207)).to.equal(0x07);

  402.     });

  403. 

  404.     it("Adding Switchable Banks", function(){

  405.       let b2 = new Mem.Memory.ROM(1);

  406.       expect(function(){

  407.         mmc.connectMemory(b2, 0x0100);

  408.       }).to.throw("Memory modules assigned to the same bank must be the same byte size.");

  409.       expect(function(){

  410.         mmc.connectMemory(b2, 0xEE)

  411.       }).to.throw("Cannot align memory module to bank at address " + (0xEE));

  412.       mmc.connectMemory(b2, 0x00);

  413.       expect(mmc.read(0x00)).to.equal(0x01);

  414.       expect(mmc.read(0x01)).to.equal(0x02);

  415.       mmc.switchBank(0x01);

  416.       expect(mmc.read(0x01)).to.equal(0x00);

  417.       mmc.switchBank(0x00);

  418.       expect(mmc.read(0x01)).to.equal(0x02);

  419. 

  420.       mmc.connectMemory(new Mem.Memory.ROM(2), 0x0100);

  421.       expect(mmc.read(0x0115)).to.equal(0x15);

  422.       mmc.switchBank(0x11);

  423.       expect(mmc.read(0x0115)).to.equal(0x00);

  424.       mmc.switchBank(0x10);

  425.       expect(mmc.read(0x0115)).to.equal(0x15);

  426.     });

  427. 

  428.     it("Write Check 2 (switch between RAM and ROM)", function(){

  429.       mmc.write(0x0115, 0x16);

  430.       expect(mmc.read(0x0115)).to.equal(0x16);

  431.       mmc.switchBank(0x11);

  432.       expect(mmc.read(0x0115)).to.equal(0x00);

  433.       mmc.write(0x0115, 0x17);

  434.       expect(mmc.read(0x0115)).to.equal(0x00);

  435.       mmc.switchBank(0x10);

  436.       expect(mmc.read(0x0115)).to.equal(0x16);

  437.     });

  438. 

  439.     it("Set Address / Get Byte", function(){

  440.       mmc.address = 0x0200;

  441.       expect(mmc.byte).to.equal(0x11);

  442.       mmc.address = 0x0301;

  443.       expect(mmc.byte).to.equal(0xBB);

  444.       mmc.address = 0x03;

  445.       expect(mmc.byte).to.equal(0x04);

  446.     });

  447. 

  448.     it("Set Address / Set Byte", function(){

  449.       mmc.address = 0xEE;

  450.       mmc.byte = 0x1A;

  451.       mmc.address = 0xEF;

  452.       mmc.byte = 0x2B;

  453.       mmc.address = 0xF0;

  454.       mmc.byte = 0x3C;

  455.       expect(mmc.read(0xEE)).to.equal(0x1A);

  456.       expect(mmc.read(0xEF)).to.equal(0x2B);

  457.       expect(mmc.read(0xF0)).to.equal(0x3C);

  458.     });

  459. 

  460.     it("Address Within Memory Bounds", function(){

  461.       mmc.address = 0x05;

  462.       expect(mmc.address).to.equal(0x05);

  463.       mmc.address = 0x0201

  464.       expect(mmc.address).to.equal(0x0201);

  465.       mmc.address = -1;

  466.       expect(mmc.address).to.equal(0);

  467.       mmc.address = 0x0400;

  468.       expect(mmc.address).to.equal(0x03FF);

  469.     });

  470. 

  471.     it("Peek");

  472.     it("Poke");

  473. 

  474.     it("Clear Page", function(){

  475.       expect(mmc.read(0x0200)).to.equal(0x11);

  476.       expect(mmc.read(0x0201)).to.equal(0x22);

  477.       mmc.clearPage(2);

  478.       expect(mmc.read(0x0200)).to.equal(0x00);

  479.       expect(mmc.read(0x0201)).to.equal(0x00);

  480.       expect(mmc.read(0xEE)).to.equal(0x1A);

  481.       mmc.clearPage(0);

  482.       expect(mmc.read(0x00)).to.equal(0x00);

  483.       expect(mmc.read(0xEE)).to.equal(0x00);

  484.       expect(mmc.read(0xEF)).to.equal(0x00);

  485.     });

  486. 

  487.     it("Clear", function(){

  488.       mmc.clear();

  489.       for (let i=0; i < 10; i++){

  490.         expect(mmc.read(0xF6 + i)).to.equal(0x00);

  491.       }

  492.     });

  493.   });

  494. });

  495. 

  496. 

  497.