How to use executeAnd method in unexpected

Best JavaScript code snippet using unexpected

emulator.js

Source:emulator.js

...1065        }1066        else if (op === 0xA7) {1067            // AND A           1068            this.PC++;1069            return this.executeAnd(this.A);1070        }1071        else if (op === 0xA0) {1072            // AND B           1073            this.PC++;1074            return this.executeAnd(this.B);1075        }1076        else if (op === 0xA1) {1077            // AND C1078            this.PC++;1079            return this.executeAnd(this.C);1080        }1081        else if (op === 0xA2) {1082            // AND D1083            this.PC++;1084            return this.executeAnd(this.D);1085        }1086        else if (op === 0xA3) {1087            // AND E1088            this.PC++;1089            return this.executeAnd(this.E);1090        }1091        else if (op === 0xA4) {1092            // AND H1093            this.PC++;1094            return this.executeAnd(this.H());1095        }1096        else if (op === 0xA5) {1097            // AND L1098            this.PC++;1099            return this.executeAnd(this.L());1100        }1101        else if (op === 0xA6) {1102            // AND (HL)1103            this.PC++;1104            return this.executeAnd(this.bus.readByte(this.HL));1105        }1106        else if (op === 0x28) {1107            // JR Z, r81108            const value = this.bus.readByte(this.PC + 1);1109            const offset = utils_1.makeSigned(value, 1);1110            this.PC += 2;1111            if (this.getFlag(exports.ZERO_FLAG)) {1112                // jumped1113                this.PC += offset;1114                return 12;1115            }1116            else {1117                // not jumped1118                return 8;1119            }1120        }1121        else if (op === 0xC0) {1122            // RET NZ1123            if (!this.getFlag(exports.ZERO_FLAG)) {1124                const lsb = this.stackPop();1125                const msb = this.stackPop();1126                const addr = (msb << 8) | lsb;1127                this.PC = addr;1128                return 20;1129            }1130            else {1131                this.PC++;1132                return 8;1133            }1134        }1135        else if (op === 0xC8) {1136            // 'RET Z'1137            if (this.getFlag(exports.ZERO_FLAG)) {1138                const lsb = this.stackPop();1139                const msb = this.stackPop();1140                const addr = (msb << 8) | lsb;1141                this.PC = addr;1142                return 20;1143            }1144            else {1145                this.PC++;1146                return 8;1147            }1148        }1149        else if (op === 0xD0) {1150            // 'RET NC'1151            if (!this.getFlag(exports.CARRY_FLAG)) {1152                const lsb = this.stackPop();1153                const msb = this.stackPop();1154                const addr = (msb << 8) | lsb;1155                this.PC = addr;1156                return 20;1157            }1158            else {1159                this.PC++;1160                return 8;1161            }1162        }1163        else if (op === 0xD8) {1164            // RET C1165            if (this.getFlag(exports.CARRY_FLAG)) {1166                const lsb = this.stackPop();1167                const msb = this.stackPop();1168                const addr = (msb << 8) | lsb;1169                this.PC = addr;1170                return 20;1171            }1172            else {1173                this.PC++;1174                return 8;1175            }1176        }1177        else if (op === 0xDE) {1178            // SBC A, d81179            const value = this.bus.readByte(this.PC + 1);1180            this.A = this.sbcInstruction(value);1181            this.PC += 2;1182            return 8;1183        }1184        else if (op === 0xFA) {1185            // 'LD A, (a16)';1186            const value = this.readTwoByteValue(this.PC + 1);1187            this.A = this.bus.readByte(value);1188            this.PC += 3;1189            return 16;1190        }1191        else if (op === 0x3D) {1192            // DEC A1193            const result = wrappingByteSub(this.A, 1);1194            this.updateSubHalfCarryFlag(this.A, 1);1195            this.A = result[0];1196            this.setFlag(exports.SUBTRACTION_FLAG);1197            this.updateZeroFlag(this.A);1198            this.PC++;1199            return 4;1200        }1201        else if (op === 0x2D) {1202            // DEC L1203            this.decrementL();1204            this.PC++;1205            return 4;1206        }1207        else if (op === 0x11) {1208            // LD DE, d161209            const lsb = this.bus.readByte(this.PC + 1);1210            const msb = this.bus.readByte(this.PC + 2);1211            this.D = msb;1212            this.E = lsb;1213            this.PC += 3;1214            return 12;1215        }1216        else if (op === 0x7E) {1217            // LD A, (HL)1218            this.A = this.bus.readByte(this.HL);1219            this.PC++;1220            return 8;1221        }1222        else if (op === 0x6E) {1223            // LD L, (HL)1224            const value = this.bus.readByte(this.HL);1225            this.HL = (this.H() << 8) | value;1226            this.PC++;1227            return 8;1228        }1229        else if (op === 0x5E) {1230            // LD E, (HL)1231            this.E = this.bus.readByte(this.HL);1232            this.PC++;1233            return 8;1234        }1235        else if (op === 0x4E) {1236            // LD C, (HL)1237            this.C = this.bus.readByte(this.HL);1238            this.PC++;1239            return 8;1240        }1241        else if (op === 0xB7) {1242            // OR A1243            this.A = this.A | this.A;1244            this.updateZeroFlagAndClearOthers();1245            this.PC++;1246            return 4;1247        }1248        else if (op === 0xC1) {1249            // POP BC1250            this.C = this.stackPop();1251            this.B = this.stackPop();1252            this.PC++;1253            return 12;1254        }1255        else if (op === 0xD1) {1256            // POP DE1257            this.E = this.stackPop();1258            this.D = this.stackPop();1259            this.PC++;1260            return 12;1261        }1262        else if (op === 0xE1) {1263            // POP HL1264            const l = this.stackPop();1265            const h = this.stackPop();1266            this.HL = (h << 8) | l;1267            this.PC++;1268            return 12;1269        }1270        else if (op === 0xF1) {1271            // POP AF1272            const popped = this.stackPop();1273            this.Flags = this.loadFlags(popped);1274            this.A = this.stackPop();1275            this.PC++;1276            return 12;1277        }1278        else if (op === 0x2F) {1279            // CPL   [complement A]1280            this.A = utils_1.bitNegation(this.A);1281            this.setFlag(exports.SUBTRACTION_FLAG);1282            this.setFlag(exports.HALF_CARRY_FLAG);1283            this.PC++;1284            return 4;1285        }1286        else if (op === 0xE6) {1287            // AND A, d81288            // Z 0 1 01289            const value = this.bus.readByte(this.PC + 1);1290            this.A = this.A & value;1291            this.updateZeroFlag(this.A);1292            this.clearFlag(exports.SUBTRACTION_FLAG);1293            this.setFlag(exports.HALF_CARRY_FLAG);1294            this.clearFlag(exports.CARRY_FLAG);1295            this.PC += 2;1296            return 8;1297        }1298        else if (op === 0x47) {1299            // LD B, A1300            this.B = this.A;1301            this.PC++;1302            return 4;1303        }1304        else if (op === 0x46) {1305            // 'LD B, (HL)';1306            this.B = this.bus.readByte(this.HL);1307            this.PC++;1308            return 8;1309        }1310        else if (op === 0x45) {1311            // 'LD B, L';1312            this.B = this.L();1313            this.PC++;1314            return 4;1315        }1316        else if (op === 0x44) {1317            // 'LD B, H';1318            this.B = this.H();1319            this.PC++;1320            return 4;1321        }1322        else if (op === 0x43) {1323            // 'LD B, E';1324            this.B = this.E;1325            this.PC++;1326            return 4;1327        }1328        else if (op === 0x42) {1329            // 'LD B, D';1330            this.B = this.D;1331            this.PC++;1332            return 4;1333        }1334        else if (op === 0x41) {1335            // 'LD B, C';1336            this.B = this.C;1337            this.PC++;1338            return 4;1339        }1340        else if (op === 0x40) {1341            // 'LD B, B';1342            this.B = this.B;1343            this.PC++;1344            return 4;1345        }1346        else if (op === 0x4F) {1347            // 'LD C, A';1348            this.C = this.A;1349            this.PC++;1350            return 4;1351        }1352        else if (op === 0x4D) {1353            // 'LD C, L';1354            this.C = this.L();1355            this.PC++;1356            return 4;1357        }1358        else if (op === 0x4C) {1359            // 'LD C, H';1360            this.C = this.H();1361            this.PC++;1362            return 4;1363        }1364        else if (op === 0x4B) {1365            // 'LD C, E';1366            this.C = this.E;1367            this.PC++;1368            return 4;1369        }1370        else if (op === 0x4A) {1371            // 'LD C, D';1372            this.C = this.D;1373            this.PC++;1374            return 4;1375        }1376        else if (op === 0x49) {1377            // 'LD C, C';1378            this.C = this.C;1379            this.PC++;1380            return 4;1381        }1382        else if (op === 0x48) {1383            // 'LD C, B';1384            this.C = this.B;1385            this.PC++;1386            return 4;1387        }1388        else if (op === 0xEF) {1389            // 'RST 28h';1390            // Push present address onto stack.1391            // Jump to address 0x00281392            this.pushAddressOnStack(this.PC + 1);1393            this.PC = 0x28;1394            return 16;1395        }1396        else if (op === 0x5F) {1397            // LD E, A1398            this.E = this.A;1399            this.PC++;1400            return 4;1401        }1402        else if (op === 0x5D) {1403            // LD E, L1404            this.E = this.L();1405            this.PC++;1406            return 4;1407        }1408        else if (op === 0x5C) {1409            // LD E, H1410            this.E = this.H();1411            this.PC++;1412            return 4;1413        }1414        else if (op === 0x5B) {1415            // LD E, E1416            this.E = this.E;1417            this.PC++;1418            return 4;1419        }1420        else if (op === 0x5A) {1421            // LD E, D1422            this.E = this.D;1423            this.PC++;1424            return 4;1425        }1426        else if (op === 0x59) {1427            // LD E, C1428            this.E = this.C;1429            this.PC++;1430            return 4;1431        }1432        else if (op === 0x58) {1433            // LD E, B1434            this.E = this.B;1435            this.PC++;1436            return 4;1437        }1438        else if (op === 0x56) {1439            // LD D, (HL)1440            this.D = this.bus.readByte(this.HL);1441            this.PC++;1442            return 8;1443        }1444        else if (op === 0x57) {1445            // LD D, A1446            this.D = this.A;1447            this.PC++;1448            return 4;1449        }1450        else if (op === 0x55) {1451            // LD D, L1452            this.D = this.L();1453            this.PC++;1454            return 4;1455        }1456        else if (op === 0x54) {1457            // LD D, H1458            this.D = this.H();1459            this.PC++;1460            return 4;1461        }1462        else if (op === 0x53) {1463            // LD D, E1464            this.D = this.E;1465            this.PC++;1466            return 4;1467        }1468        else if (op === 0x52) {1469            // LD D, D1470            this.D = this.D;1471            this.PC++;1472            return 4;1473        }1474        else if (op === 0x51) {1475            // LD D, C1476            this.D = this.C;1477            this.PC++;1478            return 4;1479        }1480        else if (op === 0x50) {1481            // LD D, B1482            this.D = this.B;1483            this.PC++;1484            return 4;1485        }1486        else if (op === 0xE8) {1487            // ADD SP, r81488            const value = this.bus.readByte(this.PC + 1);1489            const offset = utils_1.makeSigned(value, 1);1490            const result = wrappingTwoByteAdd(this.SP, offset);1491            //this.updateHalfCarryFlag(this.SP, offset);1492            if (((result[0] ^ this.SP ^ offset) & 0x1000) == 0x1000) {1493                this.setFlag(exports.HALF_CARRY_FLAG);1494            }1495            else {1496                this.clearFlag(exports.HALF_CARRY_FLAG);1497            }1498            result[1] ? this.setFlag(exports.CARRY_FLAG) : this.clearFlag(exports.CARRY_FLAG);1499            this.clearFlag(exports.ZERO_FLAG);1500            this.clearFlag(exports.SUBTRACTION_FLAG);1501            this.SP = result[0];1502            this.PC += 2;1503            return 16;1504        }1505        else if (op === 0xE9) {1506            // 'JP (HL)';1507            this.PC = this.HL;1508            return 4;1509        }1510        else if (op === 0x1A) {1511            // LD A, (DE)1512            this.A = this.bus.readByte(this.DE());1513            this.PC++;1514            return 8;1515        }1516        else if (op === 0x22) {1517            // LD (HL+),A1518            this.bus.writeByte(this.HL, this.A);1519            this.incrementHL();1520            this.PC++;1521            return 8;1522        }1523        else if (op === 0xCA) {1524            // JP Z, a161525            const addr = this.readTwoByteValue(this.PC + 1);1526            if (this.getFlag(exports.ZERO_FLAG)) {1527                this.PC = addr;1528                return 16;1529            }1530            else {1531                this.PC += 3;1532                return 12;1533            }1534        }1535        else if (op === 0x35) {1536            // DEC (HL)1537            const value = this.bus.readByte(this.HL);1538            const [result,] = wrappingTwoByteSub(value, 1);1539            this.bus.writeByte(this.HL, result[0]);1540            this.updateSubHalfCarryFlag(value, 1);1541            this.updateZeroFlag(result[0]);1542            this.setFlag(exports.SUBTRACTION_FLAG);1543            this.PC++;1544            return 12;1545        }1546        else if (op === 0x09) {1547            // ADD HL, BC1548            this.addToHLInstr(this.BC());1549            this.PC++;1550            return 8;1551        }1552        else if (op === 0x69) {1553            // LD L, C1554            this.updateL(this.C);1555            this.PC++;1556            return 4;1557        }1558        else if (op === 0x60) {1559            // LD H, B1560            this.updateH(this.B);1561            this.PC++;1562            return 4;1563        }1564        else if (op === 0x0A) {1565            // LD A, (BC)';1566            this.A = this.bus.readByte(this.BC());1567            this.PC++;1568            return 8;1569        }1570        else if (op === 0x80) {1571            // ADD A, B';1572            this.A = this.addOneByte(this.A, this.B);1573            this.PC++;1574            return 4;1575        }1576        else if (op === 0x81) {1577            // ADD A, C';1578            this.A = this.addOneByte(this.A, this.C);1579            this.PC++;1580            return 4;1581        }1582        else if (op === 0x82) {1583            // ADD A, D';1584            this.A = this.addOneByte(this.A, this.D);1585            this.PC++;1586            return 4;1587        }1588        else if (op === 0x83) {1589            // ADD A, E';1590            this.A = this.addOneByte(this.A, this.E);1591            this.PC++;1592            return 4;1593        }1594        else if (op === 0x84) {1595            // ADD A, H';1596            this.A = this.addOneByte(this.A, this.H());1597            this.PC++;1598            return 4;1599        }1600        else if (op === 0x85) {1601            // ADD A, L';1602            this.A = this.addOneByte(this.A, this.L());1603            this.PC++;1604            return 4;1605        }1606        else if (op === 0x86) {1607            // ADD A, (HL)';1608            this.A = this.addOneByte(this.A, this.bus.readByte(this.HL));1609            this.PC++;1610            return 8;1611        }1612        else if (op === 0x87) {1613            // ADD A, A;1614            this.A = this.addOneByte(this.A, this.A);1615            this.PC++;1616            return 4;1617        }1618        else if (op === 0x88) {1619            // ADC A, B';1620            const carryValue = this.getFlag(exports.CARRY_FLAG) ? 1 : 0;1621            this.addOneByte(this.A, this.B, carryValue);1622            this.PC++;1623            return 4;1624        }1625        else if (op === 0x89) {1626            // ADC A, C';1627            const carryValue = this.getFlag(exports.CARRY_FLAG) ? 1 : 0;1628            this.addOneByte(this.A, this.C, carryValue);1629            this.PC++;1630            return 4;1631        }1632        else if (op === 0x8A) {1633            // ADC A, D';1634            const carryValue = this.getFlag(exports.CARRY_FLAG) ? 1 : 0;1635            this.addOneByte(this.A, this.D, carryValue);1636            this.PC++;1637            return 4;1638        }1639        else if (op === 0x8B) {1640            // ADC A, E';1641            const carryValue = this.getFlag(exports.CARRY_FLAG) ? 1 : 0;1642            this.addOneByte(this.A, this.E, carryValue);1643            this.PC++;1644            return 4;1645        }1646        else if (op === 0x8C) {1647            // ADC A, H';1648            const carryValue = this.getFlag(exports.CARRY_FLAG) ? 1 : 0;1649            this.addOneByte(this.A, this.H(), carryValue);1650            this.PC++;1651            return 4;1652        }1653        else if (op === 0x8D) {1654            // ADC A, L';1655            const carryValue = this.getFlag(exports.CARRY_FLAG) ? 1 : 0;1656            this.addOneByte(this.A, this.L(), carryValue);1657            this.PC++;1658            return 4;1659        }1660        else if (op === 0x8E) {1661            // ADC A, (HL)';1662            const carryValue = this.getFlag(exports.CARRY_FLAG) ? 1 : 0;1663            this.addOneByte(this.A, this.bus.readByte(this.HL), carryValue);1664            this.PC++;1665            return 8;1666        }1667        else if (op === 0x8F) {1668            // ADC A, A';1669            const carryValue = this.getFlag(exports.CARRY_FLAG) ? 1 : 0;1670            this.addOneByte(this.A, this.A, carryValue);1671            this.PC++;1672            return 4;1673        }1674        else if (op === 0x6F) {1675            // LD L, A1676            this.updateL(this.A);1677            this.PC++;1678            return 4;1679        }1680        else if (op === 0x6D) {1681            // 'LD L, L';1682            this.updateL(this.L());1683            this.PC++;1684            return 4;1685        }1686        else if (op === 0x6C) {1687            // 'LD L, H';1688            this.updateL(this.H());1689            this.PC++;1690            return 4;1691        }1692        else if (op === 0x6B) {1693            // 'LD L, E';1694            this.updateL(this.E);1695            this.PC++;1696            return 4;1697        }1698        else if (op === 0x6A) {1699            // 'LD L, D';1700            this.updateL(this.D);1701            this.PC++;1702            return 4;1703        }1704        else if (op === 0x68) {1705            // 'LD L, B';1706            this.updateL(this.B);1707            this.PC++;1708            return 4;1709        }1710        else if (op === 0x61) {1711            // 'LD H, C';1712            this.updateH(this.C);1713            this.PC++;1714            return 4;1715        }1716        else if (op === 0x62) {1717            // 'LD H, D';1718            this.updateH(this.D);1719            this.PC++;1720            return 4;1721        }1722        else if (op === 0x63) {1723            // 'LD H, E';1724            this.updateH(this.E);1725            this.PC++;1726            return 4;1727        }1728        else if (op === 0x64) {1729            // 'LD H, H';1730            this.updateH(this.H());1731            this.PC++;1732            return 4;1733        }1734        else if (op === 0x65) {1735            // 'LD H, L';1736            this.updateH(this.L());1737            this.PC++;1738            return 4;1739        }1740        else if (op === 0x66) {1741            // 'LD H, (HL)';1742            this.updateH(this.bus.readByte(this.HL));1743            this.PC++;1744            return 8;1745        }1746        else if (op === 0x67) {1747            // 'LD H, A';1748            this.updateH(this.A);1749            this.PC++;1750            return 4;1751        }1752        else if (op === 0xC2) {1753            // JP NZ, a161754            const addr = this.readTwoByteValue(this.PC + 1);1755            if (!this.getFlag(exports.ZERO_FLAG)) {1756                this.PC = addr;1757                return 16;1758            }1759            else {1760                this.PC += 3;1761                return 12;1762            }1763        }1764        else if (op === 0x7A) {1765            // 'LD A, D';1766            this.A = this.D;1767            this.PC++;1768            return 4;1769        }1770        else if (op === 0x7D) {1771            // 'LD A, L';1772            this.A = this.L();1773            this.PC++;1774            return 4;1775        }1776        else if (op === 0xC6) {1777            // ADD A, d81778            const value = this.bus.readByte(this.PC + 1);1779            this.A = this.addOneByte(this.A, value);1780            this.PC += 2;1781            return 8;1782        }1783        else if (op === 0xEE) {1784            // XOR d81785            const value = this.bus.readByte(this.PC + 1);1786            this.A = this.A ^ value;1787            this.updateZeroFlagAndClearOthers();1788            this.PC += 2;1789            return 8;1790        }1791        else if (op === 0xC4) {1792            // CALL NZ, a161793            const addr = this.readTwoByteValue(this.PC + 1);1794            if (!this.Flags.zeroFlag) {1795                this.pushAddressOnStack(this.PC + 3);1796                this.PC = addr;1797                return 24;1798            }1799            else {1800                this.PC += 3;1801                return 12;1802            }1803        }1804        else if (op === 0xD6) {1805            // SUB d81806            const value = this.bus.readByte(this.PC + 1);1807            this.A = this.subOneByte(this.A, value);1808            this.PC += 2;1809            return 8;1810        }1811        else if (op === 0x26) {1812            // `LD H, d8`;1813            const value = this.bus.readByte(this.PC + 1);1814            this.updateH(value);1815            this.PC += 2;1816            return 8;1817        }1818        else if (op === 0x38) {1819            // JR C,r81820            const value = this.bus.readByte(this.PC + 1);1821            const offset = utils_1.makeSigned(value, 1);1822            this.PC += 2; // move to next instruction then add offset1823            if (this.getFlag(exports.CARRY_FLAG)) {1824                this.PC += offset;1825                return 12;1826            }1827            return 8;1828        }1829        else if (op === 0x30) {1830            // JR NC, r81831            const value = this.bus.readByte(this.PC + 1);1832            const offset = utils_1.makeSigned(value, 1);1833            this.PC += 2;1834            if (!this.getFlag(exports.CARRY_FLAG)) {1835                this.PC += offset;1836                return 12;1837            }1838            return 8;1839        }1840        else if (op === 0x33) {1841            // INC SP1842            this.SP = (this.SP + 1) & 0xFFFF;1843            this.PC++;1844            return 8;1845        }1846        else if (op === 0x3B) {1847            // DEC SP1848            this.SP = (this.SP - 1) & 0xFFFF;1849            this.PC++;1850            return 8;1851        }1852        else if (op === 0x73) {1853            // LD (HL), E1854            this.bus.writeByte(this.HL, this.E);1855            this.PC++;1856            return 8;1857        }1858        else if (op === 0x72) {1859            // LD (HL), D1860            this.bus.writeByte(this.HL, this.D);1861            this.PC++;1862            return 8;1863        }1864        else if (op === 0x71) {1865            // LD (HL), C1866            this.bus.writeByte(this.HL, this.C);1867            this.PC++;1868            return 8;1869        }1870        else if (op === 0x70) {1871            // LD (HL), B1872            this.bus.writeByte(this.HL, this.B);1873            this.PC++;1874            return 8;1875        }1876        else if (op === 0x77) {1877            // LD (HL), A1878            this.bus.writeByte(this.HL, this.A);1879            this.PC++;1880            return 8;1881        }1882        else if (op === 0x74 || op === 0x75) {1883            // LD (HL), n1884            const valueMap = {1885                0x74: this.H(),1886                0x75: this.L()1887            };1888            this.bus.writeByte(this.HL, valueMap[op]);1889            this.PC += 1;1890            return 8;1891        }1892        else if (op === 0x76) {1893            // HALT1894            // TODO: Halt CPU until interrupt occurs1895            this.PC++;1896            return 4;1897        }1898        else if (op === 0xF9) {1899            // LD SP, HL1900            this.SP = this.HL;1901            this.PC++;1902            return 8;1903        }1904        else if (op === 0xCE) {1905            // ADC A, d81906            const value = this.bus.readByte(this.PC + 1);1907            const carryValue = this.getFlag(exports.CARRY_FLAG) ? 0x01 : 0x00;1908            this.A = this.addOneByte(this.A, value, carryValue);1909            this.PC += 2;1910            return 8;1911        }1912        else if (op >= 0xB0 && op <= 0xB7) {1913            // OR n1914            const valueMap = {1915                0x0: this.B,1916                0x1: this.C,1917                0x2: this.D,1918                0x3: this.E,1919                0x4: this.H(),1920                0x5: this.L(),1921                0x6: this.bus.readByte(this.HL),1922                0x7: this.A1923            };1924            this.A = this.A | valueMap[op & 0x0F];1925            this.updateZeroFlagAndClearOthers();1926            this.PC++;1927            return op === 0xB6 ? 8 : 4;1928        }1929        else if (op === 0x1E) {1930            // LD E, d81931            this.E = this.bus.readByte(this.PC + 1);1932            this.PC += 2;1933            return 8;1934        }1935        else if (op === 0xF6) {1936            // OR d81937            const value = this.bus.readByte(this.PC + 1);1938            this.executeOr(value);1939            this.PC += 2;1940            return 8;1941        }1942        else if (op === 0x03) {1943            // INC BC1944            this.incrementBC();1945            this.PC++;1946            return 8;1947        }1948        else if (op === 0x04) {1949            // INC B1950            this.B = this.incrementRegister(this.B);1951            this.PC++;1952            return 4;1953        }1954        else if (op === 0x0C) {1955            // INC C1956            this.C = this.incrementRegister(this.C);1957            this.PC++;1958            return 4;1959        }1960        else if (op === 0x14) {1961            // INC D1962            this.D = this.incrementRegister(this.D);1963            this.PC++;1964            return 4;1965        }1966        else if (op === 0x1C) {1967            // INC E1968            this.E = this.incrementRegister(this.E);1969            this.PC++;1970            return 4;1971        }1972        else if ([0x13, 0x23, 0x24, 0x2C, 0x34, 0x3C].includes(op)) {1973            const opMap = {1974                0x13: () => this.incrementDE(),1975                0x23: () => this.incrementHL(),1976                0x24: () => this.incrementH(),1977                0x2C: () => this.incrementL(),1978                0x34: () => {1979                    const value = this.bus.readByte(this.HL);1980                    const [result,] = wrappingByteAdd(value, 1);1981                    //this.updateHalfCarryFlag(value, 1);1982                    this.clearFlag(exports.HALF_CARRY_FLAG);1983                    if (((result[0] ^ value ^ 1) & 0x10) == 0x10) {1984                        this.setFlag(exports.HALF_CARRY_FLAG);1985                    }1986                    this.clearFlag(exports.SUBTRACTION_FLAG);1987                    this.updateZeroFlag(result);1988                    this.bus.writeByte(this.HL, result);1989                },1990                0x3C: () => {1991                    const result = wrappingByteAdd(this.A, 1);1992                    //this.updateHalfCarryFlag(this.A, 1);1993                    this.clearFlag(exports.HALF_CARRY_FLAG);1994                    if (((result[0] ^ this.A ^ 1) & 0x10) == 0x10) {1995                        this.setFlag(exports.HALF_CARRY_FLAG);1996                    }1997                    this.clearFlag(exports.SUBTRACTION_FLAG);1998                    this.updateZeroFlag(result[0]);1999                    this.A = result[0];2000                }2001            };2002            if (opMap[op]) {2003                opMap[op]();2004            }2005            this.PC++;2006            if (op === 0x34) {2007                return 12;2008            }2009            return [0x13, 0x23].includes[op] ? 8 : 4;2010        }2011        else if (op >= 0x90 && op <= 0x97 || op === 0xD6) {2012            // SUB n2013            // Subtract n from A2014            if (op === 0xD6) {2015                const value = this.bus.readByte(this.PC + 1);2016                this.A = this.subOneByte(this.A, value);2017                this.PC += 2;2018                return 8;2019            }2020            if (op === 0x96) {2021                const value = this.bus.readByte(this.HL);2022                this.A = this.subOneByte(this.A, value);2023                this.PC++;2024                return 8;2025            }2026            const opMap = {2027                0x90: () => { return this.subOneByte(this.A, this.B); },2028                0x91: () => { return this.subOneByte(this.A, this.C); },2029                0x92: () => { return this.subOneByte(this.A, this.D); },2030                0x93: () => { return this.subOneByte(this.A, this.E); },2031                0x94: () => { return this.subOneByte(this.A, this.H()); },2032                0x95: () => { return this.subOneByte(this.A, this.L()); },2033                0x97: () => { return this.subOneByte(this.A, this.A); }2034            };2035            this.A = opMap[op]();2036            this.PC++;2037            return 4;2038        }2039        else if (op === 0xF8) {2040            // https://stackoverflow.com/questions/5159603/gbz80-how-does-ld-hl-spe-affect-h-and-c-flags/72611492041            // https://stackoverflow.com/questions/57958631/game-boy-half-carry-flag-and-16-bit-instructions-especially-opcode-0xe82042            // `LD HL, SP + ${value}`;2043            // TODO: half-carry AND carry flags might not be setting correctly2044            const value = this.bus.readByte(this.PC + 1);2045            const offset = utils_1.makeSigned(value, 1);2046            const result = wrappingTwoByteAdd(this.SP, offset);2047            //this.updateHalfCarryFlag(this.SP, offset);2048            if (((result[0] ^ this.SP ^ offset) & 0x1000) == 0x1000) {2049                this.setFlag(exports.HALF_CARRY_FLAG);2050            }2051            else {2052                this.clearFlag(exports.HALF_CARRY_FLAG);2053            }2054            this.clearFlag(exports.CARRY_FLAG);2055            if (result[1]) {2056                this.setFlag(exports.CARRY_FLAG);2057            }2058            this.HL = result[0];2059            this.clearFlag(exports.SUBTRACTION_FLAG);2060            this.clearFlag(exports.ZERO_FLAG);2061            this.PC += 2;2062            return 12;2063        }2064        else if (op >= 0xB8 && op <= 0xBF) {2065            // Compare A with n. This is basically an A - n subtraction instruction but the results are thrown away.2066            // CP d82067            const value = this.getRegisterValueInvolved(op);2068            let result = wrappingByteSub(this.A, value);2069            this.updateZeroFlag(result[0]);2070            this.setFlag(exports.SUBTRACTION_FLAG);2071            this.updateSubHalfCarryFlag(this.A, value);2072            result[1] ? this.setFlag(exports.CARRY_FLAG) : this.clearFlag(exports.CARRY_FLAG);2073            this.PC++;2074            return op === 0xBE ? 8 : 4;2075        }2076        else if (op === 0x27) {2077            // DAA2078            this.daaInstruction();2079            this.PC++;2080            return 4;2081        }2082        else if (op === 0x2E) {2083            // LD L,d82084            const value = this.bus.readByte(this.PC + 1);2085            this.updateL(value);2086            this.PC += 2;2087            return 8;2088        }2089        else if (op === 0x1B) {2090            // DEC DE2091            this.decrementDE();2092            this.PC++;2093            return 8;2094        }2095        else if (op === 0x2B) {2096            // DEC HL2097            this.decrementHL();2098            this.PC++;2099            return 8;2100        }2101        else if (op === 0x37) {2102            // SCF2103            // Set Carry flag2104            this.setFlag(exports.CARRY_FLAG);2105            this.clearFlag(exports.SUBTRACTION_FLAG);2106            this.clearFlag(exports.HALF_CARRY_FLAG);2107            this.PC++;2108            return 4;2109        }2110        else if (op === 0x3F) {2111            // CCF2112            // Complement carry flag2113            this.getFlag(exports.CARRY_FLAG) ? this.clearFlag(exports.CARRY_FLAG) : this.setFlag(exports.CARRY_FLAG);2114            this.clearFlag(exports.SUBTRACTION_FLAG);2115            this.clearFlag(exports.HALF_CARRY_FLAG);2116            this.PC++;2117            return 4;2118        }2119        else if (op === 0x98) {2120            // SBC B2121            this.A = this.sbcInstruction(this.B);2122            this.PC++;2123            return 4;2124        }2125        else if (op === 0x99) {2126            // SBC C2127            this.A = this.sbcInstruction(this.C);2128            this.PC++;2129            return 4;2130        }2131        else if (op === 0x9A) {2132            this.A = this.sbcInstruction(this.D);2133            this.PC++;2134            return 4;2135        }2136        else if (op === 0x9B) {2137            this.A = this.sbcInstruction(this.E);2138            this.PC++;2139            return 4;2140        }2141        else if (op === 0x9C) {2142            this.A = this.sbcInstruction(this.H());2143            this.PC++;2144            return 4;2145        }2146        else if (op === 0x9D) {2147            this.A = this.sbcInstruction(this.L());2148            this.PC++;2149            return 4;2150        }2151        else if (op === 0x9E) {2152            const value = this.bus.readByte(this.HL);2153            this.A = this.sbcInstruction(value);2154            this.PC++;2155            return 8;2156        }2157        else if (op === 0x9F) {2158            // SBC A2159            this.sbcInstruction(this.A);2160            this.PC++;2161            return 4;2162        }2163        else if (op === 0xA8) {2164            // XOR B2165            this.A = this.A ^ this.B;2166            this.updateZeroFlagAndClearOthers();2167            this.PC++;2168            return 4;2169        }2170        else if (op === 0xA9) {2171            // XOR C2172            this.A = this.A ^ this.C;2173            this.updateZeroFlagAndClearOthers();2174            this.PC++;2175            return 4;2176        }2177        else if (op === 0xAA) {2178            // XOR D2179            this.A = this.A ^ this.D;2180            this.updateZeroFlagAndClearOthers();2181            this.PC++;2182            return 4;2183        }2184        else if (op === 0xAB) {2185            // XOR E2186            this.A = this.A ^ this.E;2187            this.updateZeroFlagAndClearOthers();2188            this.PC++;2189            return 4;2190        }2191        else if (op === 0xAC) {2192            // XOR H2193            this.A = this.A ^ this.H();2194            this.updateZeroFlagAndClearOthers();2195            this.PC++;2196            return 4;2197        }2198        else if (op === 0xAD) {2199            // XOR L2200            this.A = this.A ^ this.L();2201            this.updateZeroFlagAndClearOthers();2202            this.PC++;2203            return 4;2204        }2205        else if (op === 0xAE) {2206            // XOR (HL)2207            const value = this.bus.readByte(this.HL);2208            this.A = this.A ^ value;2209            this.updateZeroFlagAndClearOthers();2210            this.PC++;2211            return 8;2212        }2213        else if (op === 0xAF) {2214            // XOR A2215            this.A = this.A ^ this.A;2216            this.updateZeroFlagAndClearOthers();2217            this.PC++;2218            return 4;2219        }2220        else if (op === 0x17) {2221            // RLA2222            this.A = this.rotateLeftThroughCarry(this.A);2223            this.clearFlag(exports.ZERO_FLAG);2224            this.PC++;2225            return 4;2226        }2227        else if (op === 0x0F) {2228            // RRCA2229            // Rotate A right. Old bit 0 to Carry flag.2230            this.A = this.rotateRight(this.A);2231            this.clearFlag(exports.ZERO_FLAG);2232            this.PC++;2233            return 4;2234        }2235        else if (op === 0x23) {2236            // INC HL2237            this.incrementHL();2238            this.PC++;2239            return 8;2240        }2241        else if (op === 0xC4) {2242            // CALL NZ, a162243            const addr = this.readTwoByteValue(this.PC + 1);2244            if (!this.getFlag(exports.ZERO_FLAG)) {2245                // push address after this instruction on to the stack2246                this.pushAddressOnStack(this.PC + 3); // 3 because this instruction is 3 bytes long 2247                this.PC = addr;2248                return 24;2249            }2250            this.PC += 3;2251            return 12;2252        }2253        else if (op === 0xD4) {2254            // CALL NC, a162255            const addr = this.readTwoByteValue(this.PC + 1);2256            if (!this.getFlag(exports.CARRY_FLAG)) {2257                // push address after this instruction on to the stack2258                this.pushAddressOnStack(this.PC + 3); // 3 because this instruction is 3 bytes long 2259                this.PC = addr;2260                return 24;2261            }2262            this.PC += 3;2263            return 12;2264        }2265        else if (op === 0xCC) {2266            // CALL Z, a162267            const addr = this.readTwoByteValue(this.PC + 1);2268            if (this.getFlag(exports.ZERO_FLAG)) {2269                // push address after this instruction on to the stack2270                this.pushAddressOnStack(this.PC + 3); // 3 because this instruction is 3 bytes long 2271                this.PC = addr;2272                return 24;2273            }2274            this.PC += 3;2275            return 12;2276        }2277        else if (op === 0xDC) {2278            // CALL C, a162279            const addr = this.readTwoByteValue(this.PC + 1);2280            if (this.getFlag(exports.CARRY_FLAG)) {2281                // push address after this instruction on to the stack2282                this.pushAddressOnStack(this.PC + 3); // 3 because this instruction is 3 bytes long 2283                this.PC = addr;2284                return 24;2285            }2286            this.PC += 3;2287            return 12;2288        }2289        else if (op === 0xCF) {2290            // RST 0x082291            this.rstInstruction(0x08); // fn changes PC address2292            return 16;2293        }2294        else if (op === 0xDF) {2295            // RST 0x182296            this.rstInstruction(0x18); // fn changes PC address2297            return 16;2298        }2299        else if (op === 0xEF) {2300            // RST 0x282301            this.rstInstruction(0x28); // fn changes PC address2302            return 16;2303        }2304        else if (op === 0xC7) {2305            // RST 0x002306            this.rstInstruction(0x00); // fn changes PC address2307            return 16;2308        }2309        else if (op === 0xD7) {2310            // RST 0x102311            this.rstInstruction(0x10); // fn changes PC address2312            return 16;2313        }2314        else if (op === 0xE7) {2315            // RST 0x202316            this.rstInstruction(0x20); // fn changes PC address2317            return 16;2318        }2319        else if (op === 0xF7) {2320            // RST 0x302321            this.rstInstruction(0x30); // fn changes PC address2322            return 16;2323        }2324        else if (op === 0xCB) {2325            let nextInstrByte = this.bus.readByte(this.PC + 1);2326            switch (nextInstrByte) {2327                case 0x00:2328                    // RLC B2329                    this.B = this.rotateLeft(this.B);2330                    this.PC += 2;2331                    return 8;2332                case 0x01:2333                    // RLC C2334                    this.C = this.rotateLeft(this.C);2335                    this.PC += 2;2336                    return 8;2337                case 0x02:2338                    // RLC D2339                    this.D = this.rotateLeft(this.D);2340                    this.PC += 2;2341                    return 8;2342                case 0x03:2343                    // RLC E2344                    this.E = this.rotateLeft(this.E);2345                    this.PC += 2;2346                    return 8;2347                case 0x04:2348                    // RLC H2349                    this.updateH(this.rotateLeft(this.H()));2350                    this.PC += 2;2351                    return 8;2352                case 0x05:2353                    // RLC L2354                    this.updateL(this.rotateLeft(this.L()));2355                    this.PC += 2;2356                    return 8;2357                case 0x06:2358                    // RLC (HL)2359                    let b = this.bus.readByte(this.HL);2360                    b = this.rotateLeft(b);2361                    this.bus.writeByte(this.HL, b);2362                    this.PC += 2;2363                    return 8;2364                case 0x07:2365                    // RLC A2366                    this.A = this.rotateLeft(this.A);2367                    this.PC += 2;2368                    return 8;2369                case 0x08:2370                    // RRC B2371                    this.B = this.rotateRight(this.B);2372                    this.PC += 2;2373                    return 8;2374                case 0x09:2375                    // RRC C2376                    this.C = this.rotateRight(this.C);2377                    this.PC += 2;2378                    return 8;2379                case 0x0A:2380                    // RRC D2381                    this.D = this.rotateRight(this.D);2382                    this.PC += 2;2383                    return 8;2384                case 0x0B:2385                    // RRC E2386                    this.E = this.rotateRight(this.E);2387                    this.PC += 2;2388                    return 8;2389                case 0x0C:2390                    // RRC H2391                    this.updateH(this.rotateRight(this.H()));2392                    this.PC += 2;2393                    return 8;2394                case 0x0D:2395                    // RRC L2396                    this.updateL(this.rotateRight(this.L()));2397                    this.PC += 2;2398                    return 8;2399                case 0x0E:2400                    // RRC (HL)2401                    let b2 = this.bus.readByte(this.HL);2402                    b2 = this.rotateRight(b2);2403                    this.bus.writeByte(this.HL, b2);2404                    this.PC += 2;2405                    return 8;2406                case 0x0F:2407                    // RRC A2408                    this.A = this.rotateRight(this.A);2409                    this.PC += 2;2410                    return 8;2411                case 0x10:2412                    // RL B2413                    this.B = this.rotateLeftThroughCarry(this.B);2414                    this.PC += 2;2415                    return 8;2416                case 0x11:2417                    // RL C2418                    this.C = this.rotateLeftThroughCarry(this.C);2419                    this.PC += 2;2420                    return 8;2421                case 0x12:2422                    // RL D2423                    this.D = this.rotateLeftThroughCarry(this.D);2424                    this.PC += 2;2425                    return 8;2426                case 0x13:2427                    // RL E2428                    this.E = this.rotateLeftThroughCarry(this.E);2429                    this.PC += 2;2430                    return 8;2431                case 0x14:2432                    // RL H2433                    this.updateH(this.rotateLeftThroughCarry(this.H()));2434                    this.PC += 2;2435                    return 8;2436                case 0x15:2437                    // RL L2438                    this.updateL(this.rotateLeftThroughCarry(this.L()));2439                    this.PC += 2;2440                    return 8;2441                case 0x16:2442                    // RL (HL)2443                    let b3 = this.bus.readByte(this.HL);2444                    b3 = this.rotateLeftThroughCarry(b3);2445                    this.bus.writeByte(this.HL, b3);2446                    this.PC += 2;2447                    return 8;2448                case 0x17:2449                    // RL A2450                    this.A = this.rotateLeftThroughCarry(this.A);2451                    this.PC += 2;2452                    return 8;2453                case 0x18:2454                    // 'RR B'2455                    this.B = this.rotateRightThroughCarry(this.B);2456                    this.PC += 2;2457                    return 8;2458                case 0x19:2459                    // 'RR C'2460                    // Rotate n right through Carry flag.2461                    this.C = this.rotateRightThroughCarry(this.C);2462                    this.PC += 2;2463                    return 8;2464                case 0x1A:2465                    // 'RR D';2466                    this.D = this.rotateRightThroughCarry(this.D);2467                    this.PC += 2;2468                    return 8;2469                case 0x1B:2470                    // 'RR E';2471                    this.E = this.rotateRightThroughCarry(this.E);2472                    this.PC += 2;2473                    return 8;2474                case 0x1C:2475                    // 'RR H';2476                    this.updateH(this.rotateRightThroughCarry(this.H()));2477                    this.PC += 2;2478                    return 8;2479                case 0x1D:2480                    // 'RR L';2481                    this.updateL(this.rotateRightThroughCarry(this.L()));2482                    this.PC += 2;2483                    return 8;2484                case 0x1E:2485                    // 'RR (HL)';2486                    const b6 = this.bus.readByte(this.HL);2487                    this.bus.writeByte(this.HL, this.rotateRightThroughCarry(b6));2488                    this.PC += 2;2489                    return 16;2490                case 0x1F:2491                    // 'RR A';2492                    this.A = this.rotateRightThroughCarry(this.A);2493                    this.PC += 2;2494                    return 8;2495                case 0x20:2496                    // SLA B2497                    this.B = this.shiftLeftIntoCarry(this.B);2498                    this.PC += 2;2499                    return 8;2500                case 0x21:2501                    // SLA C2502                    this.C = this.shiftLeftIntoCarry(this.C);2503                    this.PC += 2;2504                    return 8;2505                case 0x22:2506                    // SLA D2507                    this.D = this.shiftLeftIntoCarry(this.D);2508                    this.PC += 2;2509                    return 8;2510                case 0x23:2511                    // SLA E2512                    this.E = this.shiftLeftIntoCarry(this.E);2513                    this.PC += 2;2514                    return 8;2515                case 0x24:2516                    // SLA H2517                    this.updateH(this.shiftLeftIntoCarry(this.H()));2518                    this.PC += 2;2519                    return 8;2520                case 0x25:2521                    // SLA L2522                    this.updateL(this.shiftLeftIntoCarry(this.L()));2523                    this.PC += 2;2524                    return 8;2525                case 0x26:2526                    // SLA (HL)2527                    const b4 = this.bus.readByte(this.HL);2528                    this.bus.writeByte(this.HL, this.shiftLeftIntoCarry(b4));2529                case 0x27:2530                    // SLA A2531                    // Shift n left into Carry. LSB of n set to 02532                    this.A = this.shiftLeftIntoCarry(this.A);2533                    this.PC += 2;2534                    return 8;2535                case 0x28:2536                    // SRA B2537                    this.B = this.shiftRightIntoCarry(this.B);2538                    this.PC += 2;2539                    return 8;2540                case 0x29:2541                    // SRA C2542                    this.C = this.shiftRightIntoCarry(this.C);2543                    this.PC += 2;2544                    return 8;2545                case 0x2A:2546                    // SRA D2547                    this.D = this.shiftRightIntoCarry(this.D);2548                    this.PC += 2;2549                    return 8;2550                case 0x2B:2551                    // SRA E2552                    this.E = this.shiftRightIntoCarry(this.E);2553                    this.PC += 2;2554                    return 8;2555                case 0x2C:2556                    // SRA H2557                    this.updateH(this.shiftRightIntoCarry(this.H()));2558                    this.PC += 2;2559                    return 8;2560                case 0x2D:2561                    // SRA L2562                    this.updateL(this.shiftRightIntoCarry(this.L()));2563                    this.PC += 2;2564                    return 8;2565                case 0x2E:2566                    // SRA (HL)2567                    const b5 = this.bus.readByte(this.HL);2568                    this.bus.writeByte(this.HL, this.shiftRightIntoCarry(b5));2569                    this.PC += 2;2570                    return 8;2571                case 0x2F:2572                    // SRA A2573                    this.A = this.shiftRightIntoCarry(this.A);2574                    this.PC += 2;2575                    return 8;2576                case 0x30:2577                    // SWAP B2578                    this.swapNibblesOf(this.B);2579                    this.PC += 2;2580                    return 8;2581                case 0x31:2582                    // SWAP C2583                    this.swapNibblesOf(this.C);2584                    this.PC += 2;2585                    return 8;2586                case 0x32:2587                    // SWAP D2588                    this.swapNibblesOf(this.D);2589                    this.PC += 2;2590                    return 8;2591                case 0x33:2592                    // SWAP E2593                    this.swapNibblesOf(this.E);2594                    this.PC += 2;2595                    return 8;2596                case 0x34:2597                    // SWAP H2598                    const swappedH = this.swapNibblesOf(this.H());2599                    this.HL = (swappedH << 8) | this.L();2600                    this.PC += 2;2601                    return 8;2602                case 0x35:2603                    // SWAP L2604                    const swappedL = this.swapNibblesOf(this.L());2605                    this.HL = (this.H() << 8) | swappedL;2606                    this.PC += 2;2607                    return 8;2608                case 0x36:2609                    // SWAP (HL)2610                    const swapValue = this.bus.readByte(this.HL);2611                    const swapped = this.swapNibblesOf(swapValue);2612                    this.bus.writeByte(this.HL, swapped);2613                    this.PC += 2;2614                    return 16;2615                case 0x37:2616                    // SWAP A2617                    this.swapNibblesOf(this.A);2618                    this.PC += 2;2619                    return 8;2620                case 0x38:2621                    // SRL B2622                    this.B = this.shiftRight(this.B);2623                    this.PC += 2;2624                    return 8;2625                case 0x39:2626                    // SRL C2627                    this.C = this.shiftRight(this.C);2628                    this.PC += 2;2629                    return 8;2630                case 0x3A:2631                    // SRL D2632                    this.D = this.shiftRight(this.D);2633                    this.PC += 2;2634                    return 8;2635                case 0x3B:2636                    // SRL E2637                    this.E = this.shiftRight(this.E);2638                    this.PC += 2;2639                    return 8;2640                case 0x3C:2641                    // SRL H2642                    this.updateH(this.shiftRight(this.H()));2643                    this.PC += 2;2644                    return 8;2645                case 0x3D:2646                    // SRL L2647                    this.updateL(this.shiftRight(this.L()));2648                    this.PC += 2;2649                    return 8;2650                case 0x3E:2651                    // SRL (HL)2652                    const v = this.bus.readByte(this.HL);2653                    const updated = this.shiftRightIntoCarry(v);2654                    this.bus.writeByte(this.HL, updated);2655                    this.PC += 2;2656                    return 16;2657                case 0x3F:2658                    // SRL E2659                    this.A = this.shiftRightIntoCarry(this.A);2660                    this.PC += 2;2661                    return 8;2662                case 0x40:2663                    // BIT 0, B2664                    return this.updateZeroFlagWithBit(this.B, 0);2665                case 0x41:2666                    // BIT 0, C2667                    return this.updateZeroFlagWithBit(this.C, 0);2668                case 0x42:2669                    // BIT 0, D2670                    return this.updateZeroFlagWithBit(this.D, 0);2671                case 0x43:2672                    // BIT 0, E2673                    return this.updateZeroFlagWithBit(this.E, 0);2674                case 0x44:2675                    // BIT 0, H2676                    return this.updateZeroFlagWithBit(this.H(), 0);2677                case 0x45:2678                    // BIT 0, L2679                    return this.updateZeroFlagWithBit(this.L(), 0);2680                case 0x46:2681                    // BIT 0, (HL)2682                    this.updateZeroFlagWithBit(this.bus.readByte(this.HL), 0);2683                    return 16;2684                case 0x47:2685                    // BIT 0, A2686                    return this.updateZeroFlagWithBit(this.A, 0);2687                case 0x48:2688                    // BIT 1, B2689                    return this.updateZeroFlagWithBit(this.B, 1);2690                case 0x49:2691                    // BIT 1, C2692                    return this.updateZeroFlagWithBit(this.C, 1);2693                case 0x4A:2694                    // BIT 1, D2695                    return this.updateZeroFlagWithBit(this.D, 1);2696                case 0x4B:2697                    // BIT 1, E2698                    return this.updateZeroFlagWithBit(this.E, 1);2699                case 0x4C:2700                    // BIT 1, H2701                    return this.updateZeroFlagWithBit(this.H(), 1);2702                case 0x4D:2703                    // BIT 1, L2704                    return this.updateZeroFlagWithBit(this.L(), 1);2705                case 0x4E:2706                    // BIT 1, (HL)2707                    this.updateZeroFlagWithBit(this.bus.readByte(this.HL), 1);2708                    return 16;2709                case 0x4F:2710                    // BIT 1, A2711                    return this.updateZeroFlagWithBit(this.A, 1);2712                case 0x50:2713                    // BIT 2, B2714                    return this.updateZeroFlagWithBit(this.B, 2);2715                case 0x51:2716                    // 'BIT 2, C';2717                    return this.updateZeroFlagWithBit(this.C, 2);2718                case 0x52:2719                    // 'BIT 2, D';2720                    return this.updateZeroFlagWithBit(this.D, 2);2721                case 0x53:2722                    // 'BIT 2, E';2723                    return this.updateZeroFlagWithBit(this.E, 2);2724                case 0x54:2725                    // 'BIT 2, H';2726                    return this.updateZeroFlagWithBit(this.H(), 2);2727                case 0x55:2728                    // 'BIT 2, L';2729                    return this.updateZeroFlagWithBit(this.L(), 2);2730                case 0x56:2731                    // 'BIT 2, (HL)';2732                    this.updateZeroFlagWithBit(this.bus.readByte(this.HL), 2);2733                    return 16;2734                case 0x57:2735                    // 'BIT 2, A';2736                    return this.updateZeroFlagWithBit(this.A, 2);2737                case 0x58:2738                    // BIT 3, B2739                    return this.updateZeroFlagWithBit(this.B, 3);2740                case 0x59:2741                    // BIT 3, C2742                    return this.updateZeroFlagWithBit(this.C, 3);2743                case 0x5A:2744                    // BIT 3, D2745                    return this.updateZeroFlagWithBit(this.D, 3);2746                case 0x5B:2747                    // BIT 3, E2748                    return this.updateZeroFlagWithBit(this.E, 3);2749                case 0x5C:2750                    // BIT 3, H2751                    return this.updateZeroFlagWithBit(this.H(), 3);2752                case 0x5D:2753                    // BIT 3, L2754                    return this.updateZeroFlagWithBit(this.L(), 3);2755                case 0x5E:2756                    // BIT 3, (HL)2757                    this.updateZeroFlagWithBit(this.bus.readByte(this.HL), 3);2758                    return 16;2759                case 0x5F:2760                    // BIT 3, A2761                    return this.updateZeroFlagWithBit(this.A, 3);2762                case 0x70:2763                    // BIT 6, B2764                    return this.updateZeroFlagWithBit(this.B, 6);2765                case 0x71:2766                    // BIT 6, C2767                    return this.updateZeroFlagWithBit(this.C, 6);2768                case 0x72:2769                    // BIT 6, D2770                    return this.updateZeroFlagWithBit(this.D, 6);2771                case 0x73:2772                    // BIT 6, E2773                    return this.updateZeroFlagWithBit(this.E, 6);2774                case 0x74:2775                    // BIT 6, H2776                    return this.updateZeroFlagWithBit(this.H(), 6);2777                case 0x75:2778                    // BIT 6, L2779                    return this.updateZeroFlagWithBit(this.L(), 6);2780                case 0x76:2781                    // BIT 6, (HL)2782                    this.updateZeroFlagWithBit(this.bus.readByte(this.HL), 6);2783                    return 16;2784                case 0x77:2785                    // BIT 6, A2786                    return this.updateZeroFlagWithBit(this.A, 6);2787                case 0x78:2788                    // BIT 7, B2789                    return this.updateZeroFlagWithBit(this.B, 7);2790                case 0x79:2791                    // BIT 7, C2792                    return this.updateZeroFlagWithBit(this.C, 7);2793                case 0x7A:2794                    // BIT 7, D2795                    return this.updateZeroFlagWithBit(this.D, 7);2796                case 0x7B:2797                    // BIT 7, E2798                    return this.updateZeroFlagWithBit(this.E, 7);2799                case 0x7C:2800                    // BIT 7, H2801                    return this.updateZeroFlagWithBit(this.H(), 7);2802                case 0x7D:2803                    // BIT 7, L2804                    return this.updateZeroFlagWithBit(this.L(), 7);2805                case 0x7E:2806                    // BIT 7, (HL)2807                    this.updateZeroFlagWithBit(this.bus.readByte(this.HL), 7);2808                    return 16;2809                case 0x7F:2810                    // Updates Z, is zero flag2811                    // BIT 7, A2812                    return this.updateZeroFlagWithBit(this.A, 7);2813                case 0x87:2814                    // 'RES 0, A'2815                    // Reset bit u3 in register r8 to 0. Bit 0 is the rightmost one, bit 7 the leftmost one.2816                    this.A = this.resetBitInstruction(this.A, 0);2817                    return 8;2818                case 0x86:2819                    // RES 0, (HL)2820                    return this.resetHLBitInstruction(0);2821                case 0xA0:2822                    // RES 4, B2823                    this.B = this.resetBitInstruction(this.B, 4);2824                    return 8;2825                case 0xA1:2826                    // RES 4, C2827                    this.C = this.resetBitInstruction(this.C, 4);2828                    return 8;2829                case 0xA2:2830                    // RES 4, D2831                    this.D = this.resetBitInstruction(this.D, 4);2832                    return 8;2833                case 0xA3:2834                    // RES 4, E2835                    this.E = this.resetBitInstruction(this.E, 4);2836                    return 8;2837                case 0xA7:2838                    // RES 4, A2839                    this.A = this.resetBitInstruction(this.A, 4);2840                    return 8;2841                case 0xA8:2842                    // RES 5, B2843                    this.B = this.resetBitInstruction(this.B, 5);2844                    return 8;2845                case 0xA9:2846                    // RES 5, C2847                    this.C = this.resetBitInstruction(this.C, 5);2848                    return 8;2849                case 0xAA:2850                    // RES 5, D2851                    this.D = this.resetBitInstruction(this.D, 5);2852                    return 8;2853                case 0xAB:2854                    // RES 5, E2855                    this.E = this.resetBitInstruction(this.E, 5);2856                    return 8;2857                case 0xAE:2858                    // RES 5, (HL)2859                    return this.resetHLBitInstruction(5);2860                case 0xAF:2861                    // RES 5, A2862                    this.A = this.resetBitInstruction(this.A, 5);2863                    return 8;2864                case 0xE0:2865                    // SET 4, B2866                    this.B = this.setBitInstruction(this.B, 4);2867                    return 8;2868                case 0xE1:2869                    // SET 4, C2870                    this.C = this.setBitInstruction(this.C, 4);2871                    return 8;2872                case 0xE2:2873                    // SET 4, D2874                    this.D = this.setBitInstruction(this.D, 4);2875                    return 8;2876                case 0xE3:2877                    // SET 4, E2878                    this.E = this.setBitInstruction(this.E, 4);2879                    return 8;2880                case 0xE4:2881                    // SET 4, H2882                    return this.setHBitInstruction(4);2883                case 0xE5:2884                    // SET 4, L2885                    return this.setLBitInstruction(4);2886                case 0xE6:2887                    // SET 4, (HL)2888                    return this.setHLBitInstruction(4);2889                case 0xE7:2890                    // SET 4, A2891                    this.A = this.setBitInstruction(this.A, 4);2892                    return 8;2893                case 0xE8:2894                    // SET 5, B2895                    this.B = this.setBitInstruction(this.B, 5);2896                    return 8;2897                case 0xE9:2898                    // SET 5, C2899                    this.C = this.setBitInstruction(this.C, 5);2900                    return 8;2901                case 0xEA:2902                    // SET 5, D2903                    this.D = this.setBitInstruction(this.D, 5);2904                    return 8;2905                case 0xEB:2906                    // SET 5, E2907                    this.E = this.setBitInstruction(this.E, 5);2908                    return 8;2909                case 0xEC:2910                    // SET 5, H2911                    return this.setHBitInstruction(5);2912                case 0xED:2913                    // SET 5, L2914                    return this.setLBitInstruction(5);2915                case 0xEE:2916                    // SET 5, (HL)2917                    return this.setHLBitInstruction(5);2918                case 0xEF:2919                    // SET 5, A2920                    this.A = this.setBitInstruction(this.A, 5);2921                    return 8;2922                default:2923                    console.log(`Error: encountered an unsupported opcode of ${utils_1.displayAsHex(op)} ${utils_1.displayAsHex(nextInstrByte)} at address ${utils_1.displayAsHex(this.PC)}`);2924                    return 0;2925            }2926        }2927        console.log(`Error: encountered an unsupported opcode of ${utils_1.displayAsHex(op)} at address ${utils_1.displayAsHex(this.PC)}`);2928        return 0;2929    }2930    sbcInstruction(value) {2931        const carryFlag = this.getFlag(exports.CARRY_FLAG) ? 1 : 0;2932        return this.subOneByte(this.A, value, carryFlag);2933    }2934    rstInstruction(rstAddr) {2935        this.pushAddressOnStack(this.PC + 1);2936        this.PC = rstAddr;2937    }2938    // NO BUGS HERE. LITERALLY A PERFECT IMPLEMENTATION2939    daaInstruction() {2940        if (!this.getFlag(exports.SUBTRACTION_FLAG)) {2941            if (this.getFlag(exports.HALF_CARRY_FLAG) || (this.A & 0x0F) > 9) {2942                this.A += 0x06;2943            }2944            if (this.getFlag(exports.CARRY_FLAG) || this.A > 0x9F) {2945                this.A += 0x60;2946            }2947        }2948        else {2949            if (this.getFlag(exports.HALF_CARRY_FLAG)) {2950                this.A = (this.A - 6) & 0xFF;2951            }2952            if (this.getFlag(exports.CARRY_FLAG)) {2953                this.A -= 0x60;2954            }2955        }2956        this.clearFlag(exports.HALF_CARRY_FLAG);2957        if ((this.A & 0x100) === 0x100) {2958            this.setFlag(exports.CARRY_FLAG);2959        }2960        this.A &= 0xFF;2961        this.clearFlag(exports.ZERO_FLAG);2962        if (this.A === 0) {2963            this.setFlag(exports.ZERO_FLAG);2964        }2965    }2966    pushAddressOnStack(returnAddr) {2967        const [higherByte, lowerByte] = this.split16BitValueIntoTwoBytes(returnAddr);2968        this.stackPush(higherByte);2969        this.stackPush(lowerByte);2970    }2971    rotateLeftThroughCarry(value) {2972        const currCarry = this.Flags.carryFlag;2973        this.Flags.carryFlag = (value & 0x80) === 0x80;2974        let updated = value << 1;2975        if (currCarry) {2976            updated ^= 0x01;2977        }2978        this.Flags.zeroFlag = updated === 0x00;2979        this.clearFlag(exports.SUBTRACTION_FLAG);2980        this.clearFlag(exports.HALF_CARRY_FLAG);2981        return updated;2982    }2983    rotateLeft(value) {2984        const bit7 = (value & 0x80) === 0x80;2985        let updated = value << 1;2986        this.clearFlag(exports.CARRY_FLAG);2987        if (bit7) {2988            this.setFlag(exports.CARRY_FLAG);2989            updated ^= 0x01;2990        }2991        this.Flags.zeroFlag = updated === 0x00;2992        this.clearFlag(exports.SUBTRACTION_FLAG);2993        this.clearFlag(exports.HALF_CARRY_FLAG);2994        return updated;2995    }2996    rotateRightThroughCarry(value) {2997        // 1001 10102998        // 0011 010[0] | [1]2999        const currCarry = this.Flags.carryFlag ? 0x80 : 0x00;3000        this.Flags.carryFlag = (value & 0x01) === 0x01;3001        let updated = value >>> 1;3002        if (currCarry === 0x80) {3003            updated ^= currCarry;3004        }3005        this.Flags.zeroFlag = updated === 0x00;3006        this.clearFlag(exports.SUBTRACTION_FLAG);3007        this.clearFlag(exports.HALF_CARRY_FLAG);3008        return updated;3009    }3010    rotateRight(value) {3011        const bit0 = (value & 0x01) === 0x01;3012        let updated = value >>> 1;3013        this.clearFlag(exports.CARRY_FLAG);3014        if (bit0) {3015            this.setFlag(exports.CARRY_FLAG);3016            updated ^= 0x80;3017        }3018        this.Flags.zeroFlag = updated === 0x00;3019        this.clearFlag(exports.SUBTRACTION_FLAG);3020        this.clearFlag(exports.HALF_CARRY_FLAG);3021        return updated;3022    }3023    // 0x28 - 0x2F3024    shiftRightIntoCarry(value) {3025        this.clearFlag(exports.CARRY_FLAG);3026        if ((value & 0x01) === 0x01) {3027            this.setFlag(exports.CARRY_FLAG);3028        }3029        const updated = (value >>> 1) | (value & 0x80);3030        this.Flags.zeroFlag = updated === 0x00;3031        this.clearFlag(exports.SUBTRACTION_FLAG);3032        this.clearFlag(exports.HALF_CARRY_FLAG);3033        return updated;3034    }3035    shiftLeftIntoCarry(value) {3036        this.clearFlag(exports.CARRY_FLAG);3037        if ((value & 0x80) === 0x80) {3038            this.setFlag(exports.CARRY_FLAG);3039        }3040        const updated = value << 1;3041        this.Flags.zeroFlag = updated === 0x00;3042        this.clearFlag(exports.SUBTRACTION_FLAG);3043        this.clearFlag(exports.HALF_CARRY_FLAG);3044        return updated;3045    }3046    shiftRight(value) {3047        this.clearFlag(exports.CARRY_FLAG);3048        if ((value & 0x01) === 0x01) {3049            this.setFlag(exports.CARRY_FLAG);3050        }3051        const updated = value >>> 1;3052        this.Flags.zeroFlag = updated === 0x00;3053        this.clearFlag(exports.SUBTRACTION_FLAG);3054        this.clearFlag(exports.HALF_CARRY_FLAG);3055        return updated;3056    }3057    updateZeroFlagWithBit(value, bit) {3058        const val = this.getBit(value, bit);3059        val === 1 ? this.setFlag(exports.ZERO_FLAG) : this.clearFlag(exports.ZERO_FLAG);3060        this.clearFlag(exports.SUBTRACTION_FLAG);3061        this.setFlag(exports.HALF_CARRY_FLAG);3062        this.PC += 2;3063        return 8;3064    }3065    getBitInstruction(value, bit) {3066        const updated = this.getBit(value, bit);3067        this.PC += 2;3068    }3069    getBit(value, bit) {3070        return ((0x1 << bit) & value) >> bit;3071    }3072    // has side-effect of modifying this.PC3073    setBitInstruction(value, bit) {3074        const updated = this.setBit(value, bit);3075        this.PC += 2;3076        return updated;3077    }3078    setHBitInstruction(bit) {3079        this.updateH(this.setBit(this.H(), bit));3080        this.PC += 2;3081        return 8;3082    }3083    setLBitInstruction(bit) {3084        this.updateL(this.setBit(this.L(), bit));3085        this.PC += 2;3086        return 8;3087    }3088    setHLBitInstruction(bit) {3089        const value = this.bus.readByte(this.HL);3090        const updated = this.setBit(value, bit);3091        this.bus.writeByte(this.HL, updated);3092        this.PC += 2;3093        return 16;3094    }3095    setBit(value, bit) {3096        return value | (0x1 << bit);3097    }3098    resetBitInstruction(value, bit) {3099        const updated = this.clearBit(value, 0);3100        this.PC += 2;3101        return updated;3102    }3103    resetHLBitInstruction(bit) {3104        const value = this.bus.readByte(this.HL);3105        const updated = this.clearBit(value, bit);3106        this.bus.writeByte(this.HL, updated);3107        this.PC += 2;3108        return 16;3109    }3110    clearBit(value, bit) {3111        const mask = 0x1 << bit;3112        return value & ~mask;3113    }3114    executeAnd(operand) {3115        this.A = this.A & operand;3116        this.updateZeroFlag(this.A);3117        this.clearFlag(exports.SUBTRACTION_FLAG);3118        this.setFlag(exports.HALF_CARRY_FLAG);3119        this.clearFlag(exports.CARRY_FLAG);3120        return 4; // consumes 4 cycles3121    }3122    // TODO: Only used by 0xF6 opcode3123    executeOr(operand) {3124        this.A = this.A | operand;3125        this.updateZeroFlag(this.A);3126        this.clearFlag(exports.SUBTRACTION_FLAG);3127        this.clearFlag(exports.HALF_CARRY_FLAG);3128        this.clearFlag(exports.CARRY_FLAG);...

vm.js

Source:vm.js

1/* eslint-disable import/no-cycle */2import { message } from 'antd';3import moment from 'moment-timezone';4import { VMSelectors } from '../reducers';5export const ACTION_RESET = 'vm:ACTION_RESET';6export const ACTION_RESTART = 'vm:ACTION_RESTART';7export const ACTION_SAVE_INITIAL_CODE = 'vm:ACTION_SAVE_INITIAL_CODE';8export const ACTION_SAVE_PROGRAM_STACK = 'vm:ACTION_SAVE_PROGRAM_STACK';9export const ACTION_SAVE_INSTRUCTION_POINTER =10  'vm:ACTION_SAVE_INSTRUCTION_POINTER';11export const ACTION_SAVE_DATA_POINTER = 'vm:ACTION_SAVE_DATA_POINTER';12export const ACTION_INSERT_DATA_STACK = 'vm:ACTION_INSERT_DATA_STACK';13export const ACTION_SAVE_WAITING_INPUT = 'vm:ACTION_SAVE_WAITING_INPUT';14export const ACTION_SAVE_EXECUTING = 'vm:ACTION_SAVE_EXECUTING';15export const ACTION_SAVE_RUNNING_EXECUTION = 'vm:ACTION_SAVE_RUNNING_EXECUTION';16export const ACTION_INSERT_CONSOLE_STACK = 'vm:ACTION_INSERT_CONSOLE_STACK';17export const ACTION_SAVE_BREAKPOINTS = 'vm:ACTION_SAVE_BREAKPOINTS';18export const reset = () => ({ type: ACTION_RESET });19export const restart = () => ({ type: ACTION_RESTART });20export const saveInitialCode = (code) => ({21  type: ACTION_SAVE_INITIAL_CODE,22  payload: code,23});24export const saveProgramStack = (array) => ({25  type: ACTION_SAVE_PROGRAM_STACK,26  payload: array,27});28export const saveInstructionPointer = (value) => ({29  type: ACTION_SAVE_INSTRUCTION_POINTER,30  payload: value,31});32export const saveDataPointer = (value) => ({33  type: ACTION_SAVE_DATA_POINTER,34  payload: value,35});36export const saveExecuting = (value) => ({37  type: ACTION_SAVE_EXECUTING,38  payload: value,39});40export const saveRunningExecution = (value) => ({41  type: ACTION_SAVE_RUNNING_EXECUTION,42  payload: value,43});44export const saveBreakpoints = (array) => ({45  type: ACTION_SAVE_BREAKPOINTS,46  payload: array,47});48// Help Functions49export const incrementInstructionPointer = () => (dispatch, getState) => {50  const instructionPointer = VMSelectors.getInstructionPointer(getState());51  dispatch(saveInstructionPointer(instructionPointer + 1));52};53export const decrementInstructionPointer = () => (dispatch, getState) => {54  const instructionPointer = VMSelectors.getInstructionPointer(getState());55  dispatch(saveInstructionPointer(instructionPointer - 1));56};57export const incrementDataPointer = () => (dispatch, getState) => {58  const dataPointer = VMSelectors.getDataPointer(getState());59  dispatch(saveDataPointer(dataPointer + 1));60};61export const decrementDataPointer = () => (dispatch, getState) => {62  const dataPointer = VMSelectors.getDataPointer(getState());63  dispatch(saveDataPointer(dataPointer - 1));64};65export const insertDataStack = (value, increment = 0) => (66  dispatch,67  getState68) => {69  const dataPointer = VMSelectors.getDataPointer(getState());70  dispatch({71    type: ACTION_INSERT_DATA_STACK,72    payload: { value, index: dataPointer + increment },73  });74};75export const insertConsoleStack = (value) => (dispatch) => {76  dispatch({77    type: ACTION_INSERT_CONSOLE_STACK,78    payload: {79      time: moment().format('HH:mm'),80      message: value,81    },82  });83};84// Execution Functions85export const executeLDC = (k) => (dispatch, getState) => {86  dispatch(incrementDataPointer());87  const dataPointer = VMSelectors.getDataPointer(getState());88  dispatch(insertDataStack({ value: k, index: dataPointer }));89};90export const executeLDV = (n) => (dispatch, getState) => {91  dispatch(incrementDataPointer());92  const dataPointer = VMSelectors.getDataPointer(getState());93  dispatch(94    insertDataStack({95      value: VMSelectors.getDataStackByPosition(getState(), n).value,96      index: dataPointer,97    })98  );99};100export const executeADD = () => (dispatch, getState) => {101  const dataPointer = VMSelectors.getDataPointer(getState());102  const lastData = VMSelectors.getDataStackByPosition(103    getState(),104    dataPointer - 1105  );106  const actualData = VMSelectors.getDataStackByPosition(107    getState(),108    dataPointer109  );110  const newData = {111    value: lastData.value + actualData.value,112    index: dataPointer - 1,113  };114  dispatch(insertDataStack(newData, -1));115  dispatch(decrementDataPointer());116};117export const executeSUB = () => (dispatch, getState) => {118  const dataPointer = VMSelectors.getDataPointer(getState());119  const lastData = VMSelectors.getDataStackByPosition(120    getState(),121    dataPointer - 1122  );123  const actualData = VMSelectors.getDataStackByPosition(124    getState(),125    dataPointer126  );127  const newData = {128    value: lastData.value - actualData.value,129    index: dataPointer - 1,130  };131  dispatch(insertDataStack(newData, -1));132  dispatch(decrementDataPointer());133};134export const executeMULT = () => (dispatch, getState) => {135  const dataPointer = VMSelectors.getDataPointer(getState());136  const lastData = VMSelectors.getDataStackByPosition(137    getState(),138    dataPointer - 1139  );140  const actualData = VMSelectors.getDataStackByPosition(141    getState(),142    dataPointer143  );144  const newData = {145    value: lastData.value * actualData.value,146    index: dataPointer - 1,147  };148  dispatch(insertDataStack(newData, -1));149  dispatch(decrementDataPointer());150};151export const executeDIVI = () => (dispatch, getState) => {152  const dataPointer = VMSelectors.getDataPointer(getState());153  const lastData = VMSelectors.getDataStackByPosition(154    getState(),155    dataPointer - 1156  );157  const actualData = VMSelectors.getDataStackByPosition(158    getState(),159    dataPointer160  );161  const newData = {162    value: lastData.value / actualData.value,163    index: dataPointer - 1,164  };165  dispatch(insertDataStack(newData, -1));166  dispatch(decrementDataPointer());167};168export const executeINV = () => (dispatch, getState) => {169  const dataPointer = VMSelectors.getDataPointer(getState()); // s170  const actualData = VMSelectors.getDataStackByPosition(171    getState(),172    dataPointer173  ); // M[s]174  const newData = {175    value: -actualData.value,176    index: dataPointer,177  };178  dispatch(insertDataStack(newData));179};180export const executeAND = () => (dispatch, getState) => {181  const dataPointer = VMSelectors.getDataPointer(getState()); // s182  const lastData = VMSelectors.getDataStackByPosition(183    getState(),184    dataPointer - 1185  ); // M[s - 1]186  const actualData = VMSelectors.getDataStackByPosition(187    getState(),188    dataPointer189  ); // M[s]190  if (lastData.value === 1 && actualData.value === 1) {191    dispatch(insertDataStack({ value: 1, index: dataPointer - 1 }, -1));192  } else {193    dispatch(insertDataStack({ value: 0, index: dataPointer - 1 }, -1));194  }195  dispatch(decrementDataPointer());196};197export const executeOR = () => (dispatch, getState) => {198  const dataPointer = VMSelectors.getDataPointer(getState()); // s199  const lastData = VMSelectors.getDataStackByPosition(200    getState(),201    dataPointer - 1202  ); // M[s - 1]203  const actualData = VMSelectors.getDataStackByPosition(204    getState(),205    dataPointer206  ); // M[s]207  if (lastData.value === 1 || actualData.value === 1) {208    dispatch(insertDataStack({ value: 1, index: dataPointer - 1 }, -1));209  } else {210    dispatch(insertDataStack({ value: 0, index: dataPointer - 1 }, -1));211  }212  dispatch(decrementDataPointer());213};214export const executeNEG = () => (dispatch, getState) => {215  const dataPointer = VMSelectors.getDataPointer(getState()); // s216  const actualData = VMSelectors.getDataStackByPosition(217    getState(),218    dataPointer219  ); // M[s]220  const newData = {221    value: 1 - actualData.value,222    index: dataPointer,223  };224  dispatch(insertDataStack(newData));225};226export const executeCME = () => (dispatch, getState) => {227  const dataPointer = VMSelectors.getDataPointer(getState()); // s228  const actualData = VMSelectors.getDataStackByPosition(229    getState(),230    dataPointer231  ); // M[s]232  const lastData = VMSelectors.getDataStackByPosition(233    getState(),234    dataPointer - 1235  ); // M[s - 1]236  if (lastData.value < actualData.value) {237    dispatch(insertDataStack({ value: 1, index: dataPointer - 1 }, -1));238  } else {239    dispatch(insertDataStack({ value: 0, index: dataPointer - 1 }, -1));240  }241  dispatch(decrementDataPointer());242};243export const executeCMA = () => (dispatch, getState) => {244  const dataPointer = VMSelectors.getDataPointer(getState()); // s245  const actualData = VMSelectors.getDataStackByPosition(246    getState(),247    dataPointer248  ); // M[s]249  const lastData = VMSelectors.getDataStackByPosition(250    getState(),251    dataPointer - 1252  ); // M[s - 1]253  if (lastData.value > actualData.value) {254    dispatch(insertDataStack({ value: 1, index: dataPointer - 1 }, -1));255  } else {256    dispatch(insertDataStack({ value: 0, index: dataPointer - 1 }, -1));257  }258  dispatch(decrementDataPointer());259};260export const executeCEQ = () => (dispatch, getState) => {261  const dataPointer = VMSelectors.getDataPointer(getState()); // s262  const actualData = VMSelectors.getDataStackByPosition(263    getState(),264    dataPointer265  ); // M[s]266  const lastData = VMSelectors.getDataStackByPosition(267    getState(),268    dataPointer - 1269  ); // M[s - 1]270  if (lastData.value === actualData.value) {271    dispatch(insertDataStack({ value: 1, index: dataPointer - 1 }, -1));272  } else {273    dispatch(insertDataStack({ value: 0, index: dataPointer - 1 }, -1));274  }275  dispatch(decrementDataPointer());276};277export const executeCDIF = () => (dispatch, getState) => {278  const dataPointer = VMSelectors.getDataPointer(getState()); // s279  const actualData = VMSelectors.getDataStackByPosition(280    getState(),281    dataPointer282  ); // M[s]283  const lastData = VMSelectors.getDataStackByPosition(284    getState(),285    dataPointer - 1286  ); // M[s - 1]287  if (lastData.value !== actualData.value) {288    dispatch(insertDataStack({ value: 1, index: dataPointer - 1 }, -1));289  } else {290    dispatch(insertDataStack({ value: 0, index: dataPointer - 1 }, -1));291  }292  dispatch(decrementDataPointer());293};294export const executeCMEQ = () => (dispatch, getState) => {295  const dataPointer = VMSelectors.getDataPointer(getState()); // s296  const actualData = VMSelectors.getDataStackByPosition(297    getState(),298    dataPointer299  ); // M[s]300  const lastData = VMSelectors.getDataStackByPosition(301    getState(),302    dataPointer - 1303  ); // M[s - 1]304  if (lastData.value <= actualData.value) {305    dispatch(insertDataStack({ value: 1, index: dataPointer - 1 }, -1));306  } else {307    dispatch(insertDataStack({ value: 0, index: dataPointer - 1 }, -1));308  }309  dispatch(decrementDataPointer());310};311export const executeCMAQ = () => (dispatch, getState) => {312  const dataPointer = VMSelectors.getDataPointer(getState()); // s313  const actualData = VMSelectors.getDataStackByPosition(314    getState(),315    dataPointer316  ); // M[s]317  const lastData = VMSelectors.getDataStackByPosition(318    getState(),319    dataPointer - 1320  ); // M[s - 1]321  if (lastData.value >= actualData.value) {322    dispatch(insertDataStack({ value: 1, index: dataPointer - 1 }, -1));323  } else {324    dispatch(insertDataStack({ value: 0, index: dataPointer - 1 }, -1));325  }326  dispatch(decrementDataPointer());327};328export const executeSTR = (n) => (dispatch, getState) => {329  const dataPointer = VMSelectors.getDataPointer(getState());330  const actualData = VMSelectors.getDataStackByPosition(331    getState(),332    dataPointer333  );334  dispatch(335    insertDataStack({ value: actualData.value, index: n }, n - dataPointer)336  );337  dispatch(decrementDataPointer());338};339export const executeJMP = (p) => (dispatch) => {340  dispatch(saveInstructionPointer(p));341};342export const executeJMPF = (p) => (dispatch, getState) => {343  const dataPointer = VMSelectors.getDataPointer(getState());344  const actualData = VMSelectors.getDataStackByPosition(345    getState(),346    dataPointer347  );348  if (actualData.value === 0) {349    dispatch(saveInstructionPointer(p));350  } else {351    dispatch(incrementInstructionPointer());352  }353  dispatch(decrementDataPointer());354};355export const requestUserInput = () => (dispatch) => {356  dispatch({ type: ACTION_SAVE_WAITING_INPUT, payload: true });357  dispatch(insertConsoleStack('Insira um valor:'));358  message.info('Entre com um valor no terminal');359};360export const executePRN = () => (dispatch, getState) => {361  const dataPointer = VMSelectors.getDataPointer(getState());362  const actualData = VMSelectors.getDataStackByPosition(363    getState(),364    dataPointer365  );366  dispatch(insertConsoleStack(actualData.value));367  dispatch(decrementDataPointer());368};369export const executeSTART = () => (dispatch) => {370  dispatch(saveDataPointer(-1));371  dispatch(saveExecuting(true));372};373export const executeHLT = () => (dispatch) => {374  dispatch(saveExecuting(false));375  dispatch(saveRunningExecution(false));376};377export const executeALLOC = (m, n) => (dispatch, getState) => {378  for (let k = 0; k < n; k += 1) {379    dispatch(incrementDataPointer());380    const dataPointer = VMSelectors.getDataPointer(getState());381    const data = VMSelectors.getDataStackByPosition(getState(), m + k);382    dispatch(383      insertDataStack({ value: data ? data.value : 0, index: dataPointer })384    );385  }386};387export const executeDALLOC = (m, n) => (dispatch, getState) => {388  for (let k = n - 1; k >= 0; k -= 1) {389    const dataPointer = VMSelectors.getDataPointer(getState());390    const actualData = VMSelectors.getDataStackByPosition(391      getState(),392      dataPointer393    );394    dispatch(395      insertDataStack(396        { value: actualData.value, index: m + k },397        m + k - dataPointer398      )399    );400    dispatch(decrementDataPointer());401  }402};403export const executeCALL = (p) => (dispatch, getState) => {404  dispatch(incrementDataPointer());405  const instructionPointer = VMSelectors.getInstructionPointer(getState());406  const dataPointer = VMSelectors.getDataPointer(getState());407  dispatch(408    insertDataStack({ value: instructionPointer + 1, index: dataPointer })409  );410  dispatch(saveInstructionPointer(p));411};412export const executeRETURN = () => (dispatch, getState) => {413  const dataPointer = VMSelectors.getDataPointer(getState());414  const actualData = VMSelectors.getDataStackByPosition(415    getState(),416    dataPointer417  );418  dispatch(saveInstructionPointer(actualData.value));419  dispatch(decrementDataPointer());420};421export const executeInstruction = () => (dispatch, getState) => {422  const instructionPointer = VMSelectors.getInstructionPointer(getState());423  const instruction = VMSelectors.getProgramStack(getState())[424    instructionPointer425  ];426  switch (instruction.command) {427    case 'START':428      dispatch(executeSTART());429      dispatch(incrementInstructionPointer());430      break;431    case 'LDC':432      dispatch(executeLDC(instruction.var1));433      dispatch(incrementInstructionPointer());434      break;435    case 'LDV':436      dispatch(executeLDV(instruction.var1));437      dispatch(incrementInstructionPointer());438      break;439    case 'ADD':440      dispatch(executeADD());441      dispatch(incrementInstructionPointer());442      break;443    case 'SUB':444      dispatch(executeSUB());445      dispatch(incrementInstructionPointer());446      break;447    case 'MULT':448      dispatch(executeMULT());449      dispatch(incrementInstructionPointer());450      break;451    case 'DIVI':452      dispatch(executeDIVI());453      dispatch(incrementInstructionPointer());454      break;455    case 'INV':456      dispatch(executeINV());457      dispatch(incrementInstructionPointer());458      break;459    case 'AND':460      dispatch(executeAND());461      dispatch(incrementInstructionPointer());462      break;463    case 'OR':464      dispatch(executeOR());465      dispatch(incrementInstructionPointer());466      break;467    case 'NEG':468      dispatch(executeNEG());469      dispatch(incrementInstructionPointer());470      break;471    case 'CME':472      dispatch(executeCME());473      dispatch(incrementInstructionPointer());474      break;475    case 'CMA':476      dispatch(executeCMA());477      dispatch(incrementInstructionPointer());478      break;479    case 'CEQ':480      dispatch(executeCEQ());481      dispatch(incrementInstructionPointer());482      break;483    case 'CDIF':484      dispatch(executeCDIF());485      dispatch(incrementInstructionPointer());486      break;487    case 'CMEQ':488      dispatch(executeCMEQ());489      dispatch(incrementInstructionPointer());490      break;491    case 'CMAQ':492      dispatch(executeCMAQ());493      dispatch(incrementInstructionPointer());494      break;495    case 'STR':496      dispatch(executeSTR(instruction.var1));497      dispatch(incrementInstructionPointer());498      break;499    case 'JMP':500      dispatch(executeJMP(instruction.jumpIndex));501      break;502    case 'JMPF':503      dispatch(executeJMPF(instruction.jumpIndex));504      break;505    case 'RD':506      dispatch(requestUserInput());507      break;508    case 'PRN':509      dispatch(executePRN());510      dispatch(incrementInstructionPointer());511      break;512    case 'ALLOC':513      dispatch(executeALLOC(instruction.var1, instruction.var2));514      dispatch(incrementInstructionPointer());515      break;516    case 'DALLOC':517      dispatch(executeDALLOC(instruction.var1, instruction.var2));518      dispatch(incrementInstructionPointer());519      break;520    case 'CALL':521      dispatch(executeCALL(instruction.jumpIndex));522      break;523    case 'RETURN':524      dispatch(executeRETURN());525      break;526    case 'HLT':527      dispatch(executeHLT());528      break;529    default:530      dispatch(incrementInstructionPointer());531      break;532  }533};534export const execute = () => (dispatch, getState) => {535  dispatch(saveRunningExecution(true));536  const instructionPointer = VMSelectors.getInstructionPointer(getState());537  if (instructionPointer === 0) {538    dispatch(executeInstruction());539  }540  while (VMSelectors.getIsExecuting(getState())) {541    const breakpoints = VMSelectors.getBreakpoints(getState());542    const actualI = VMSelectors.getInstructionPointer(getState());543    if (breakpoints.findIndex((index) => index === actualI) !== -1) {544      dispatch(saveRunningExecution(false));545      break;546    }547    dispatch(executeInstruction());548    const isWaitingUserInput = VMSelectors.getIsWaitingInput(getState());549    if (isWaitingUserInput) break;550  }551};552export const executeRD = (input, isRunningExecution) => (553  dispatch,554  getState555) => {556  dispatch({ type: ACTION_SAVE_WAITING_INPUT, payload: false });557  dispatch(incrementDataPointer());558  const dataPointer = VMSelectors.getDataPointer(getState());559  dispatch(insertDataStack({ value: input, index: dataPointer }));560  dispatch(incrementInstructionPointer());561  dispatch(insertConsoleStack(`Valor inserido: ${input}`));562  if (isRunningExecution) dispatch(execute());...

addAdditionalPromiseMethods.js

Source:addAdditionalPromiseMethods.js

1function addAdditionalPromiseMethods(promise, expect, subject) {2  promise.and = function (...args) {3    function executeAnd() {4      if (expect.findTypeOf(args[0]).is('expect.it')) {5        return addAdditionalPromiseMethods(args[0](subject), expect, subject);6      } else {7        return expect(subject, ...args);8      }9    }10    if (this.isFulfilled()) {11      return executeAnd();12    } else {13      return addAdditionalPromiseMethods(14        this.then(executeAnd),15        expect,16        subject17      );18    }19  };20  return promise;21}...

Using AI Code Generation

1const unexpected = require('unexpected');2const unexpectedSinon = require('unexpected-sinon');3const sinon = require('sinon');4const expect = unexpected.clone().use(unexpectedSinon);5const obj = {6  method: function() {7    return 'result';8  }9};10expect(obj.method, 'was not called');11expect(obj.method, 'was called once');12expect(obj.method, 'was called twice');13expect(obj.method, 'was called thrice');14expect(obj.method, 'was called 4 times');15expect(obj.method, 'was called 5 times');16expect(obj.method, 'was called 6 times');17expect(obj.method, 'was called 7 times');18expect(obj.method, 'was called 8 times');19expect(obj.method, 'was called 9 times');20expect(obj.method, 'was called 10 times');21expect(obj.method, 'was called 11 times');22expect(obj.method, 'was called 12 times');23expect(obj.method, 'was called 13 times');24expect(obj.method, 'was called 14 times');25expect(obj.method, 'was called 15 times');26expect(obj.method, 'was called 16 times');27expect(obj.method, 'was called 17 times');28expect(obj.method, 'was called 18 times');29expect(obj.method, 'was called 19 times');30expect(obj.method, 'was called 20 times');31expect(obj.method, 'was called 21 times');32expect(obj.method, 'was called 22 times');33expect(obj.method, 'was called 23 times');34expect(obj.method, 'was called 24 times');35expect(obj.method, 'was called 25 times');36expect(obj.method, 'was called 26 times');37expect(obj.method, 'was called 27 times');38expect(obj.method, 'was called 28 times');39expect(obj.method, 'was called 29 times');40expect(obj.method, 'was called 30 times');41expect(obj.method, 'was called 31 times');42expect(obj.method, 'was called 32 times');43expect(obj.method, 'was called 33 times');44expect(obj.method, 'was called 34 times');45expect(obj.method, 'was called 35 times');46expect(obj.method, 'was called 36 times');47expect(obj.method, 'was called 37 times');48expect(obj.method, 'was called 38 times');49expect(obj.method, 'was called 39 times');50expect(obj.method, 'was called

Using AI Code Generation

1var unexpected = require('unexpected');2var unexpectedSinon = require('unexpected-sinon');3var sinon = require('sinon');4var expect = unexpected.clone().use(unexpectedSinon);5var myObject = {6    myMethod: function () {7        return 'Hello World';8    }9};10var mySpy = sinon.spy(myObject, 'myMethod');11expect(mySpy, 'was called');12expect(mySpy, 'was called once');13expect(mySpy, 'was called twice');14expect(mySpy, 'was called thrice');15expect(mySpy, 'was called 4 times');16expect(mySpy, 'was called 5 times');17expect(mySpy, 'was called 6 times');18expect(mySpy, 'was called 7 times');19expect(mySpy, 'was called 8 times');20expect(mySpy, 'was called 9 times');21expect(mySpy, 'was called 10 times');22expect(mySpy, 'was called 11 times');23expect(mySpy, 'was called 12 times');24expect(mySpy, 'was called 13 times');25expect(mySpy, 'was called 14 times');26expect(mySpy, 'was called 15 times');27expect(mySpy, 'was called 16 times');28expect(mySpy, 'was called 17 times');29expect(mySpy, 'was called 18 times');30expect(mySpy, 'was called 19 times');31expect(mySpy, 'was called 20 times');32expect(mySpy, 'was called 21 times');33expect(mySpy, 'was called 22 times');34expect(mySpy, 'was called 23 times');35expect(mySpy, 'was called 24 times');36expect(mySpy, 'was called 25 times');37expect(mySpy, 'was called 26 times');38expect(mySpy, 'was called 27 times');39expect(mySpy, 'was called 28 times');40expect(mySpy, 'was called 29 times');41expect(mySpy, 'was called 30 times');42expect(mySpy, 'was called 31 times');43expect(mySpy, 'was called 32 times');44expect(mySpy, 'was called 33 times');45expect(mySpy, 'was called 34 times');46expect(mySpy, 'was called 35 times');47expect(mySpy, 'was called 36 times');48expect(mySpy, 'was called 37 times');49expect(mySpy, 'was called 38 times');50expect(mySpy,

Using AI Code Generation

1var exec = require('child_process').exec;2var expect = require('unexpected');3expect.addAssertion('<string> [not] to execute and [exhaustively] satisfy <any>', function (expect, subject, value) {4    return expect.promise(function (run) {5        exec(subject, function (error, stdout, stderr) {6            if (error) {7                run(function () {8                    expect.fail({9                        diff: function (output, diff, inspect, equal) {10                            return diff(stderr, '');11                        }12                    });13                });14            } else {15                run(function () {16                    expect(stdout, 'to equal', value);17                });18            }19        });20    });21});22var expect = require('unexpected');23var exec = require('child_process').exec;24describe('test', function () {25    it('should execute and satisfy', function (done) {26        expect('node test.js', 'to execute and satisfy', 'hello');27        done();28    });29});30var expect = require('unexpected');31var exec = require('child_process').exec;32describe('test', function () {33    it('should execute and satisfy', function (done) {34        expect('node test.js', 'to execute and satisfy', 'hello');35        done();36    });37});38var expect = require('unexpected');39var exec = require('child_process').exec;40describe('test', function () {41    it('should execute and satisfy', function (done) {42        expect('node test.js', 'to execute and satisfy', 'hello');43        done();44    });45});46var expect = require('unexpected');47var exec = require('child_process').exec;48describe('test', function () {49    it('should execute and satisfy', function (done) {50        expect('node test.js', 'to execute and satisfy', 'hello');51        done();52    });53});54var expect = require('unexpected');55var exec = require('child_process').exec;56describe('test', function () {57    it('should execute and satisfy', function (done) {58        expect('node test.js', 'to execute and satisfy', 'hello');59        done();60    });61});62var expect = require('unexpected');63var exec = require('child_process').exec;64describe('test', function () {65    it('should execute and satisfy', function (done) {66        expect('node

Using AI Code Generation

1var expect = require('unexpected').clone().use(require('unexpected-express'));2var app = require('./app');3expect(app, 'to yield exchange', {4});5var express = require('express');6var app = express();7app.get('/', function (req, res) {8  res.send('Hello World!');9});10module.exports = app;11  Error: expected [Function] to yield exchange { request: 'GET /', response: 200 } but got error 'TypeError: Cannot read property 'statusCode' of undefined'12var expect = require('unexpected').clone().use(require('unexpected-express'));13var app = require('./app');14expect(app, 'to yield exchange', {15});16  Error: expected [Function] to yield exchange { request: 'GET /', response: 200 } but got error 'TypeError: Cannot read property 'statusCode' of undefined'17var expect = require('unexpected').clone().use(require('unexpected-express'));18var app = require('./app');19expect(app, 'to yield exchange', {20});21  Error: expected [Function] to yield exchange { request: 'GET /', response: 200 } but got error 'TypeError: Cannot read property 'statusCode' of undefined'22var expect = require('unexpected').clone().use(require('unexpected-express'));23var app = require('./app');24expect(app, 'to yield exchange', {25});26  Error: expected [Function] to yield exchange { request: 'GET /', response: 200 } but got error 'TypeError: Cannot read property 'statusCode' of undefined'

Using AI Code Generation

1var expect = require('unexpected').clone();2expect.output.preferredWidth = 80;3expect.addAssertion('<string> to execute and output <string>', function (expect, subject, value) {4    var result = expect.execute(subject, [], {env: process.env});5    return expect(result.stdout, 'to equal', value);6});7expect('node -e "console.log(\'hello world\')"', 'to execute and output', 'hello world');8var expect = require('unexpected').clone();9expect.output.preferredWidth = 80;10expect.addAssertion('<string> to execute and output <string>', function (expect, subject, value) {11    var result = expect.executeAnd(function (result) {12        return expect(result.stdout, 'to equal', value);13    }, subject, [], {env: process.env});14    return result;15});16expect('node -e "console.log(\'hello world\')"', 'to execute and output', 'hello world');

Using AI Code Generation

1var unexpected = require('unexpected');2var expect = unexpected.clone();3expect.addAssertion('<any> to be <any>', function (expect, subject, value) {4    expect(subject, 'to equal', value);5});6expect.addAssertion('<any> to be <any>', function (expect, subject, value) {7    expect(subject, 'to equal', value);8});9expect('foo', 'to be', 'bar');10expect('foo', 'to be', 'bar');11var unexpected = require('unexpected');12var expect = unexpected.clone();13expect.addAssertion('<any> to be <any>', function (expect, subject, value) {14    expect(subject, 'to equal', value);15});16expect.addAssertion('<any> to be <any>', function (expect, subject, value) {17    expect(subject, 'to equal', value);18});19expect('foo', 'to be', 'bar');20expect('foo', 'to be', 'bar');21var unexpected = require('unexpected');22var expect = unexpected.clone();23expect.addAssertion('<any> to be <any>', function (expect, subject, value) {24    expect(subject, 'to equal', value);25});26expect.addAssertion('<any> to be <any>', function (expect, subject, value) {27    expect(subject, 'to equal', value);28});29expect('foo', 'to be', 'bar');30expect('foo', 'to be', 'bar');31var unexpected = require('unexpected');32var expect = unexpected.clone();33expect.addAssertion('<any> to be <any>', function (expect, subject, value) {34    expect(subject, 'to equal', value);35});36expect.addAssertion('<any> to be <any>', function (expect, subject, value) {37    expect(subject, 'to equal', value);38});39expect('foo', 'to be', 'bar');40expect('foo', 'to be', 'bar');

Using AI Code Generation

1var exec = require('child_process').exec;2var expect = require('unexpected').clone();3expect.addAssertion('<function> to execute and', function (expect, subject) {4    return expect.promise(function (run) {5        exec('node ' + subject, function (err, stdout, stderr) {6            if (err) {7                run(err);8            } else {9                run(null, stdout);10            }11        });12    });13});14expect(function () {15    console.log('hello');16}, 'to execute and', 'to equal', 'hello');17var exec = require('child_process').exec;18var expect = require('unexpected').clone();19expect.addAssertion('<function> to execute and', function (expect, subject) {20    return expect.promise(function (run) {21        exec('node ' + subject, function (err, stdout, stderr) {22            if (err) {23                run(err);24            } else {25                run(null, stdout);26            }27        });28    });29});30expect(function () {31    console.log('hello');32}, 'to execute and', 'to equal', 'hello');33var exec = require('child_process').exec;34var expect = require('unexpected').clone();35expect.addAssertion('<function> to execute and', function (expect, subject) {36    return expect.promise(function (run) {37        exec('node ' + subject, function (err, stdout, stderr) {38            if (err) {39                run(err);40            } else {41                run(null, stdout);42            }43        });44    });45});46expect(function () {47    console.log('hello');48}, 'to execute and', 'to equal', 'hello');

Using AI Code Generation

1const expect = require('unexpected')2  .clone()3  .use(require('unexpected-mitm'));4const unexpectedMitm = require('unexpected-mitm');5expect.addAssertion('<any> to be an array of <number>', (expect, subject) => {6  expect(subject, 'to be an array');7  expect(subject, 'to have items satisfying', 'to be a number');8});9expect.addAssertion('<any> to be an array of <string>', (expect, subject) => {10  expect(subject, 'to be an array');11  expect(subject, 'to have items satisfying', 'to be a string');12});13expect.addAssertion('<any> to be an array of <function>', (expect, subject) => {14  expect(subject, 'to be an array');15  expect(subject, 'to have items satisfying', 'to be a function');16});17expect.addAssertion('<any> to be an array of <object>', (expect, subject) => {18  expect(subject, 'to be an array');19  expect(subject, 'to have items satisfying', 'to be an object');20});21expect.addAssertion('<any> to be an array of <array>', (expect, subject) => {22  expect(subject, 'to be an array');23  expect(subject, 'to have items satisfying', 'to be an array');24});25expect.addAssertion('<any> to be an array of <any>', (expect, subject) => {26  expect(subject, 'to be an array');27});28describe('test', () => {29  it('should pass', () => {30    return expect(31      unexpectedMitm.executeAnd(32        () => {33          return [1, 2, 3];34        },35        (it) => {36          return expect(it, 'to be an array of number');37        }38    );39  });40  it('should fail', () => {41    return expect(42      unexpectedMitm.executeAnd(43        () => {44          return [1, '2', 3];45        },46        (it) => {47          return expect(it, 'to be an array of number');48        }49    );50  });51});521 passing (24ms)

Using AI Code Generation

1var expect = require('unexpected').clone();2var result = expect.executeAnd(function () {3    return 1 + 1;4}, 'to equal', 2);5var expect = require('unexpected').clone();6var result = expect.executeAnd(function () {7    return 1 + 1;8}, 'to equal', 3);9var expect = require('unexpected').clone();10var result = expect.executeAnd(function () {11    return 1 + 1;12}, 'to equal', 3, 'with error', 'expected 2 to equal 3');13var expect = require('unexpected').clone();14var result = expect.executeAnd(function () {15    return 1 + 1;16}, 'to equal', 3, 'with error', 'expected 2 to equal 3');17var expect = require('unexpected').clone();18var result = expect.executeAnd(function () {19    return 1 + 1;20}, 'to equal', 2, 'with error', 'expected 2 to equal 3');21var expect = require('unexpected').clone();22var result = expect.executeAnd(function () {23    return 1 + 1;24}, 'to equal', 2, 'with error', 'expected 2 to equal 3');25var expect = require('unexpected').clone();26var result = expect.executeAnd(function () {27    return 1 + 1;28}, 'to equal', 3, 'with error', 'expected 2 to equal 3');29var expect = require('unexpected').clone();

Using AI Code Generation

1var unexpected = require('unexpected');2var expect = unexpected.clone();3var executeAnd = function (func) {4    var originalIt = it;5    it = function (description, test) {6        it = originalIt;7        test();8    };9    func();10};11describe('some test', function () {12    executeAnd(function () {13        it('should do something', function () {14            expect(1, 'to equal', 1);15        });16    });17});18var unexpected = require('unexpected');19var expect = unexpected.clone();20var executeAnd = function (func) {21    var originalIt = it;22    it = function (description, test) {23        it = originalIt;24        test();25    };26    func();27};28describe('some test', function () {29    executeAnd(function () {30        it('should do something', function () {31            expect(1, 'to equal', 1);32        });33    });34});

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.