ObsidianBlk
/
F8
Observar 1
Favorito 0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Fantasy 8Bit system (F8), is a fantasy 8bit console and a set of libraries for creating fantasy 8bit consoles.
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
65 Commits
1 Branch
Tag: ecd453d812
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de ecd453d812
${ noResults }
F8/test/unit.src.memory.memory.spec.js

453 linhas
14KB
Original Anotar 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("Clear Page", function(){

  83.         m2.clearPage(2);

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

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

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

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

  88.       });

  89. 

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

  91.         m1.clear();

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

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

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

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

  96.       });

  97.     });

  98. 

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

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

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

  102. 

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

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

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

  106.       });

  107. 

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

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

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

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

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

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

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

  115. 

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

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

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

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

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

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

  122. 

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

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

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

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

  127.       });

  128. 

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

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

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

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

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

  134. 

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

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

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

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

  139.       });

  140. 

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

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

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

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

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

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

  147.       });

  148. 

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

  150.         m1.address = 0x82;

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

  152.         m1.address = 0x83;

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

  154. 

  155.         m2.address = 0x0101;

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

  157.         m2.address = 0x0202;

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

  159.       });

  160. 

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

  162.         m1.address = 0x86;

  163.         m1.byte = 0xFE;

  164.         m1.address = 0x87;

  165.         m1.byte = 0xEF;

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

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

  168.       });

  169. 

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

  171.         m1.address = 0x0100;

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

  173.         m2.address = -1;

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

  175.         m2.address = 0x0400;

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

  177.       });

  178. 

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

  180.         var cb = sinon.fake();

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

  182.         m2.read(0x0100);

  183.         m2.read(0x0201);

  184.         m2.address = 0x0101;

  185.         m2.byte;

  186.         m2.address = 0x0100;

  187.         m2.byte;

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

  189.       });

  190. 

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

  192.         var cb = sinon.fake();

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

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

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

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

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

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

  199.       });

  200. 

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

  202.         m2.clearPage(2);

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

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

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

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

  207.       });

  208. 

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

  210.         m1.clear();

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

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

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

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

  215.       });

  216.     });

  217. 

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

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

  220. 

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

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

  223.       });

  224. 

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

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

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

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

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

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

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

  232.       });

  233. 

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

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

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

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

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

  239.       });

  240. 

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

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

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

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

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

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

  247.       });

  248. 

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

  250.         sm.address = 0x02;

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

  252.         sm.address = 0x03;

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

  254.         sm.address = 0x04;

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

  256.         sm.address = 0x05;

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

  258.       });

  259. 

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

  261.         sm.address = 0x02;

  262.         sm.byte = 0x31;

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

  264.         sm.address = 0x06;

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

  266.         sm.byte = 0x32;

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

  268.       });

  269. 

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

  271.         sm.address = 0x0100;

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

  273.         sm.address = -1;

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

  275.       });

  276. 

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

  278.         var cb1 = sinon.fake();

  279.         var cb2 = sinon.fake();

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

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

  282.         sm.read(0x01);

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

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

  285.         sm.read(0x05);

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

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

  288.       });

  289. 

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

  291.         var cb1 = sinon.fake();

  292.         var cb2 = sinon.fake();

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

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

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

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

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

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

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

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

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

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

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

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

  305.       });

  306. 

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

  308.         sm.clearPage(0);

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

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

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

  312.       });

  313. 

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

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

  316.         sm.clear();

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

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

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

  320.       });

  321.     });

  322.   });

  323. 

  324. 

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

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

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

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

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

  330. 

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

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

  333.     });

  334. 

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

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

  337.     });

  338. 

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

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

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

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

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

  344. 

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

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

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

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

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

  350.     });

  351. 

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

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

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

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

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

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

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

  359.     });

  360. 

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

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

  363.       expect(function(){

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

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

  366.       expect(function(){

  367.         mmc.connectMemory(b2, 0xEE)

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

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

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

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

  372.       mmc.switchBank(0x01);

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

  374.       mmc.switchBank(0x00);

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

  376. 

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

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

  379.       mmc.switchBank(0x11);

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

  381.       mmc.switchBank(0x10);

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

  383.     });

  384. 

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

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

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

  388.       mmc.switchBank(0x11);

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

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

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

  392.       mmc.switchBank(0x10);

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

  394.     });

  395. 

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

  397.       mmc.address = 0x0200;

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

  399.       mmc.address = 0x0301;

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

  401.       mmc.address = 0x03;

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

  403.     });

  404. 

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

  406.       mmc.address = 0xEE;

  407.       mmc.byte = 0x1A;

  408.       mmc.address = 0xEF;

  409.       mmc.byte = 0x2B;

  410.       mmc.address = 0xF0;

  411.       mmc.byte = 0x3C;

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

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

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

  415.     });

  416. 

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

  418.       mmc.address = 0x05;

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

  420.       mmc.address = 0x0201

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

  422.       mmc.address = -1;

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

  424.       mmc.address = 0x0400;

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

  426.     });

  427. 

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

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

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

  431.       mmc.clearPage(2);

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

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

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

  435.       mmc.clearPage(0);

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

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

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

  439.     });

  440. 

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

  442.       mmc.clear();

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

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

  445.       }

  446.     });

  447.   });

  448. });

  449. 

  450. 

  451.