From e8606f90e10c64c1230a777c145dbef9cd5c8ca1 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 7 Oct 2026 18:07:49 +0100 Subject: [PATCH 01/60] Work on "Right angle" --- implement-and-rewrite-tests/implement/1-get-angle-type.js | 3 +++ 1 file changed, 3 insertions(+) diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js index 8a6fba050..3ba549bbb 100644 --- a/implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -18,4 +18,7 @@ export function getAngleType(angle) { // TODO: Implement this function + if (angle === 90) { + return "Right angle"; + } } From 53621cd70cdf15e7f327a77782b5211e00c34798 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 7 Oct 2026 18:16:57 +0100 Subject: [PATCH 02/60] Added tests for all the angles, next working on code --- .../1-get-angle-type.test.js | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js index cf50f6cad..1040e57ea 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js @@ -10,3 +10,28 @@ test("Classifies right angles", () => { const right = getAngleType(90); assert.equal(right, "Right angle"); }); +// "Acute angle" for angles greater than 0° and less than 90° +test("Classifies Acute angles", () => { + const right = getAngleType(45); + assert.equal(right, "Acute angle"); +}); +// - "Obtuse angle" for angles greater than 90° and less than 180° +test("Classifies Obtuse angles", () => { + const right = getAngleType(135); + assert.equal(right, "Obtuse angle"); +}); +// - "Straight angle" for exactly 180° +test("Classifies Straight angles", () => { + const right = getAngleType(180); + assert.equal(right, "Straight angle"); +}); +// - "Reflex angle" for angles greater than 180° and less than 360° +test("Classifies Reflex angles", () => { + const right = getAngleType(225); + assert.equal(right, "Reflex angle"); +}); +// - "Invalid angle" for angles outside the valid range. +test("Classifies Invalid angles", () => { + const right = getAngleType(360); + assert.equal(right, "Invalid angle"); +}); From 5721c8ba3093d27aa7acb5f70418c27ed84f67ee Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 7 Oct 2026 18:25:43 +0100 Subject: [PATCH 03/60] Added code for Acute angle --- implement-and-rewrite-tests/implement/1-get-angle-type.js | 2 ++ 1 file changed, 2 insertions(+) diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js index 3ba549bbb..c99d11405 100644 --- a/implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -20,5 +20,7 @@ export function getAngleType(angle) { // TODO: Implement this function if (angle === 90) { return "Right angle"; + } else if (angle <= 90 && angle >= 0) { + return "Acute angle"; } } From 5e692d8dc17155fc11274c35469dc76eff717a0d Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 7 Oct 2026 18:27:15 +0100 Subject: [PATCH 04/60] Added code for Obtuse angle --- implement-and-rewrite-tests/implement/1-get-angle-type.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js index c99d11405..3d5653d5f 100644 --- a/implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -22,5 +22,6 @@ export function getAngleType(angle) { return "Right angle"; } else if (angle <= 90 && angle >= 0) { return "Acute angle"; - } + } else if (angle <= 180 && angle >= 90) { + return "Obtuse angle"; } From b61b4b433d805e5f191c16e42f08f2e876e9c232 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 7 Oct 2026 18:31:08 +0100 Subject: [PATCH 05/60] Added code for Straight angle --- implement-and-rewrite-tests/implement/1-get-angle-type.js | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js index 3d5653d5f..6bacfee6e 100644 --- a/implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -20,8 +20,11 @@ export function getAngleType(angle) { // TODO: Implement this function if (angle === 90) { return "Right angle"; - } else if (angle <= 90 && angle >= 0) { + } else if (angle < 90 && angle >= 0) { return "Acute angle"; - } else if (angle <= 180 && angle >= 90) { + } else if (angle < 180 && angle > 90) { return "Obtuse angle"; + } else if (angle === 180) { + return "Straight angle"; + } } From 7ccf911308c57b34aab3e3269d75eb6aefc7b71a Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 7 Oct 2026 18:32:28 +0100 Subject: [PATCH 06/60] Added code for Reflex angles --- implement-and-rewrite-tests/implement/1-get-angle-type.js | 2 ++ 1 file changed, 2 insertions(+) diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js index 6bacfee6e..5335fcb75 100644 --- a/implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -26,5 +26,7 @@ export function getAngleType(angle) { return "Obtuse angle"; } else if (angle === 180) { return "Straight angle"; + } else if (angle < 360 && angle > 180) { + return "Reflex angle"; } } From 426aabbd1657e2075ff331e6df043fc3d9b65bbe Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 7 Oct 2026 18:36:20 +0100 Subject: [PATCH 07/60] Added code for Invalid angle --- implement-and-rewrite-tests/implement/1-get-angle-type.js | 2 ++ 1 file changed, 2 insertions(+) diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js index 5335fcb75..7f06a1ab8 100644 --- a/implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -28,5 +28,7 @@ export function getAngleType(angle) { return "Straight angle"; } else if (angle < 360 && angle > 180) { return "Reflex angle"; + } else if (angle >= 360 && angle <) { + return "Invalid angle"; } } From 1c3277f0655b77fc83027620d96e56ff3074123d Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Thu, 8 Oct 2026 13:18:37 +0100 Subject: [PATCH 08/60] fixed errors and rearranged code to be easier to read --- implement-and-rewrite-tests/implement/1-get-angle-type.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js index 7f06a1ab8..9fa51c5ea 100644 --- a/implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -20,15 +20,15 @@ export function getAngleType(angle) { // TODO: Implement this function if (angle === 90) { return "Right angle"; - } else if (angle < 90 && angle >= 0) { + } else if (angle >= 0 && angle < 90) { return "Acute angle"; - } else if (angle < 180 && angle > 90) { + } else if (angle > 90 && angle < 180) { return "Obtuse angle"; } else if (angle === 180) { return "Straight angle"; - } else if (angle < 360 && angle > 180) { + } else if (angle > 180 && angle < 360) { return "Reflex angle"; - } else if (angle >= 360 && angle <) { + } else if (angle <= 0 || angle >= 360) { return "Invalid angle"; } } From c4786d80df13a3148e109ba92a1a4eddcf09f3c8 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Thu, 8 Oct 2026 14:35:08 +0100 Subject: [PATCH 09/60] Set up testing requirements for the fractions --- .../2-is-proper-fraction.test.js | 22 ++++++++++++++++++- .../implement/2-is-proper-fraction.js | 4 ++++ 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js index a29084605..cf534cf23 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js @@ -6,7 +6,27 @@ import { isProperFraction } from "../implement/2-is-proper-fraction.js"; // TODO: Write tests to cover all cases. // What combinations of numerators and denominators should you test? -test("Basic proper fraction", () => { +test("Basic proper fraction: Numerator < Denominator", () => { // Example: 1/2 is a proper fraction assert.equal(isProperFraction(1, 2), true); }); + +test("Improper fraction: Numerator = Denominator", () => { + assert.equal(isProperFraction(2, 2), false); +}); + +test("improper fraction: Numerator > Denominator", () => { + assert.equal(isProperFraction(2, 1), false); +}); + +test("Improper fraction: Denominator = 0", () => { + assert.equal(isProperFraction(1, 0), false); +}); + +test("Proper fraction with negative number: -Numerator < Denominator", () => { + assert.equal(isProperFraction(-1, 2), true); +}); + +test("Improper fraction with negative number: -Numerator > Denominator", () => { + assert.equal(isProperFraction(-2, 1), false); +}); diff --git a/implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/implement-and-rewrite-tests/implement/2-is-proper-fraction.js index f983800f0..3f8d78a74 100644 --- a/implement-and-rewrite-tests/implement/2-is-proper-fraction.js +++ b/implement-and-rewrite-tests/implement/2-is-proper-fraction.js @@ -15,4 +15,8 @@ export function isProperFraction(numerator, denominator) { // TODO: Implement this function + if (Math.abs(denominator) === 0) { + return false; + } + return true; } From 707ac487f7dafc2c0d287ea11ada36093990b6bc Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Thu, 8 Oct 2026 14:40:14 +0100 Subject: [PATCH 10/60] Done the code for fractions coving test requests. --- .../implement/2-is-proper-fraction.js | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/implement-and-rewrite-tests/implement/2-is-proper-fraction.js index 3f8d78a74..7a75521e1 100644 --- a/implement-and-rewrite-tests/implement/2-is-proper-fraction.js +++ b/implement-and-rewrite-tests/implement/2-is-proper-fraction.js @@ -17,6 +17,9 @@ export function isProperFraction(numerator, denominator) { // TODO: Implement this function if (Math.abs(denominator) === 0) { return false; + } else if (Math.abs(numerator) < Math.abs(denominator)) { + return true; + } else if (Math.abs(numerator) >= Math.abs(denominator)) { + return false; } - return true; } From 16f4f20091f1e50c82ddd27959df68bf0f534910 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Thu, 8 Oct 2026 14:43:45 +0100 Subject: [PATCH 11/60] cleaned up the code --- .../implement/2-is-proper-fraction.js | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/implement-and-rewrite-tests/implement/2-is-proper-fraction.js index 7a75521e1..7b4b1f755 100644 --- a/implement-and-rewrite-tests/implement/2-is-proper-fraction.js +++ b/implement-and-rewrite-tests/implement/2-is-proper-fraction.js @@ -15,11 +15,10 @@ export function isProperFraction(numerator, denominator) { // TODO: Implement this function - if (Math.abs(denominator) === 0) { + if (denominator === 0) { return false; - } else if (Math.abs(numerator) < Math.abs(denominator)) { - return true; } else if (Math.abs(numerator) >= Math.abs(denominator)) { return false; } + return true; } From e3a8f1759a025d944c52716f099aea3da49d3d83 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Thu, 8 Oct 2026 15:54:34 +0100 Subject: [PATCH 12/60] added basic tests needed and non - card string. added in code for checks for J Q K and A --- .../3-get-card-value.test.js | 17 ++++++++++++++++- .../implement/3-get-card-value.js | 11 +++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index f5092d9b1..451d0b568 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -10,7 +10,22 @@ test("Valid single-digit card", () => { }); test("Arbitrary non-card string", () => { - assert.throws(() => getCardValue("invalid"), /Expected a number followed by a suit, but got "invalid"/, "Expected clear error"); + assert.throws( + () => getCardValue("invalid"), + /Expected a number followed by a suit, but got "invalid"/, + "Expected clear error" + ); }); // TODO: What other invalid card cases can you think of? +//Incorrect suit +test("Arbitrary non-card string", () => { + assert.throws( + () => getCardValue("2☺"), + /Expected a number followed by a suit, but got "invalid"/, + "Incorrect suit" + ); +}); +//Incorrect value + +//Incorrect order diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index 9614ab1ee..47ee4b925 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -25,4 +25,15 @@ export function getCardValue(card) { // TODO: Implement this function + let suit = card.slice(-1); + let cardNumber = card.slice(0, 1); + let value = Number(cardNumber); + + if (!(suit === "♠" || suit === "♥" || suit === "♦" || suit === "♣")) { + throw new "Incorrect suit"(); + } else if (cardNumber === "J" || cardNumber === "Q" || cardNumber === "K") { + return 10; + } else if (cardNumber === "A") { + return 11; + } } From ae7ef7726fde0221cd96fdaf5ffb25398241fcef Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Thu, 8 Oct 2026 16:37:39 +0100 Subject: [PATCH 13/60] working on code and trying to fix errors --- .../3-get-card-value.test.js | 2 +- implement-and-rewrite-tests/implement/3-get-card-value.js | 8 +++++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index 451d0b568..2774b8f5f 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -19,7 +19,7 @@ test("Arbitrary non-card string", () => { // TODO: What other invalid card cases can you think of? //Incorrect suit -test("Arbitrary non-card string", () => { +test("Incorrect suit", () => { assert.throws( () => getCardValue("2☺"), /Expected a number followed by a suit, but got "invalid"/, diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index 47ee4b925..a9df3484d 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -26,14 +26,16 @@ export function getCardValue(card) { // TODO: Implement this function let suit = card.slice(-1); - let cardNumber = card.slice(0, 1); + let cardNumber = card.slice(0, -1); let value = Number(cardNumber); if (!(suit === "♠" || suit === "♥" || suit === "♦" || suit === "♣")) { - throw new "Incorrect suit"(); + throw new Error("Incorrect suit"); } else if (cardNumber === "J" || cardNumber === "Q" || cardNumber === "K") { return 10; } else if (cardNumber === "A") { return 11; - } + } else if (value >= 2 && value <= 10) { + return value; + } else throw new Error("Expected a number followed by a suit, but got "invalid""); } From d4db67912f28e50fee117bf70c9d7d368e99f93e Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Thu, 8 Oct 2026 17:06:21 +0100 Subject: [PATCH 14/60] finished code and tests for 3 types: valid single digit card Arbitrary non-card string Incorrect suit --- .../3-get-card-value.test.js | 2 +- implement-and-rewrite-tests/implement/3-get-card-value.js | 8 +++++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index 2774b8f5f..1b3c758be 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -22,7 +22,7 @@ test("Arbitrary non-card string", () => { test("Incorrect suit", () => { assert.throws( () => getCardValue("2☺"), - /Expected a number followed by a suit, but got "invalid"/, + /Incorrect suit given/, "Incorrect suit" ); }); diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index a9df3484d..dca6b455d 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -29,13 +29,15 @@ export function getCardValue(card) { let cardNumber = card.slice(0, -1); let value = Number(cardNumber); - if (!(suit === "♠" || suit === "♥" || suit === "♦" || suit === "♣")) { - throw new Error("Incorrect suit"); + if (card.length >= 4) { + throw new Error(`Expected a number followed by a suit, but got "invalid"`); + } else if (!(suit === "♠" || suit === "♥" || suit === "♦" || suit === "♣")) { + throw new Error("Incorrect suit given"); } else if (cardNumber === "J" || cardNumber === "Q" || cardNumber === "K") { return 10; } else if (cardNumber === "A") { return 11; } else if (value >= 2 && value <= 10) { return value; - } else throw new Error("Expected a number followed by a suit, but got "invalid""); + } } From 9970ef6cc725182655afa76361ad16e3557f7773 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Thu, 8 Oct 2026 17:16:57 +0100 Subject: [PATCH 15/60] cleaned up errors i encountered . --- .../implement-tests-with-node-test/3-get-card-value.test.js | 3 --- 1 file changed, 3 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index 1b3c758be..d9ad40e87 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -26,6 +26,3 @@ test("Incorrect suit", () => { "Incorrect suit" ); }); -//Incorrect value - -//Incorrect order From 2830bf30cadb08ec5794950d0fce18c54a8a74cf Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 11:10:38 +0100 Subject: [PATCH 16/60] Added in test for Right angle. Copied test code for other angles. --- .../1-get-angle-type.test.js | 22 ++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js index e0ba786ab..921836f8f 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js @@ -12,7 +12,27 @@ test(`should return "Acute angle" when (0 < angle < 90)`, () => { }); // Case 2: Right angle +test(`should return "Right angle" when (angle = 90)`, () => { + expect(getAngleType(90)).toEqual("Right angle"); +}); // Case 3: Obtuse angles -// Case 4: Straight angle +// test(`should return "Right angle" when (angle = 90)`, () => { +// expect(getAngleType()).toEqual(" angle"); +// expect(getAngleType()).toEqual(" angle"); +// expect(getAngleType()).toEqual(" angle"); +// }); +// Case 4: Straight angle +// expect(getAngleType()).toEqual(" angle"); +// expect(getAngleType()).toEqual(" angle"); +// expect(getAngleType()).toEqual(" angle"); +// }); // Case 5: Reflex angles +// expect(getAngleType()).toEqual(" angle"); +// expect(getAngleType()).toEqual(" angle"); +// expect(getAngleType()).toEqual(" angle"); +// }); // Case 6: Invalid angles +// expect(getAngleType()).toEqual(" angle"); +// expect(getAngleType()).toEqual(" angle"); +// expect(getAngleType()).toEqual(" angle"); +// }); From c7af1dd78defa5cacf1a353cac28ce25e28613b5 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 11:13:02 +0100 Subject: [PATCH 17/60] Added test for Obtuse angles --- .../rewrite-tests-with-jest/1-get-angle-type.test.js | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js index 921836f8f..d606c3aa2 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js @@ -16,11 +16,11 @@ test(`should return "Right angle" when (angle = 90)`, () => { expect(getAngleType(90)).toEqual("Right angle"); }); // Case 3: Obtuse angles -// test(`should return "Right angle" when (angle = 90)`, () => { -// expect(getAngleType()).toEqual(" angle"); -// expect(getAngleType()).toEqual(" angle"); -// expect(getAngleType()).toEqual(" angle"); -// }); +test(`should return "Obtuse angle" when (90 < angle < 180)`, () => { + expect(getAngleType(91)).toEqual("Obtuse angle"); + expect(getAngleType(167)).toEqual("Obtuse angle"); + expect(getAngleType(179)).toEqual("Obtuse angle"); +}); // Case 4: Straight angle // expect(getAngleType()).toEqual(" angle"); // expect(getAngleType()).toEqual(" angle"); From 2fc4cd2300d64639fd0f929fd42fab7a1d1819a3 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 11:15:14 +0100 Subject: [PATCH 18/60] Added test for Straight angles --- .../rewrite-tests-with-jest/1-get-angle-type.test.js | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js index d606c3aa2..76c37e9f9 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js @@ -22,16 +22,17 @@ test(`should return "Obtuse angle" when (90 < angle < 180)`, () => { expect(getAngleType(179)).toEqual("Obtuse angle"); }); // Case 4: Straight angle -// expect(getAngleType()).toEqual(" angle"); -// expect(getAngleType()).toEqual(" angle"); -// expect(getAngleType()).toEqual(" angle"); -// }); +test(`should return "Straight angle" when (angle = 180)`, () => { + expect(getAngleType(180)).toEqual("Straight angle"); +}); // Case 5: Reflex angles +// test(`should return "Right angle" when (angle = 90)`, () => { // expect(getAngleType()).toEqual(" angle"); // expect(getAngleType()).toEqual(" angle"); // expect(getAngleType()).toEqual(" angle"); // }); // Case 6: Invalid angles +// test(`should return "Right angle" when (angle = 90)`, () => { // expect(getAngleType()).toEqual(" angle"); // expect(getAngleType()).toEqual(" angle"); // expect(getAngleType()).toEqual(" angle"); From 8662c14439b122d155eeb669e164a6f6e6a310a0 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 11:25:13 +0100 Subject: [PATCH 19/60] Added tests for Right angles --- .../rewrite-tests-with-jest/1-get-angle-type.test.js | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js index 76c37e9f9..95e1e9523 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js @@ -26,11 +26,11 @@ test(`should return "Straight angle" when (angle = 180)`, () => { expect(getAngleType(180)).toEqual("Straight angle"); }); // Case 5: Reflex angles -// test(`should return "Right angle" when (angle = 90)`, () => { -// expect(getAngleType()).toEqual(" angle"); -// expect(getAngleType()).toEqual(" angle"); -// expect(getAngleType()).toEqual(" angle"); -// }); +test(`should return "Right angle" when (180 < angle < 360)`, () => { + expect(getAngleType(186)).toEqual("Reflex angle"); + expect(getAngleType(270)).toEqual("Reflex angle"); + expect(getAngleType(359)).toEqual("Reflex angle"); +}); // Case 6: Invalid angles // test(`should return "Right angle" when (angle = 90)`, () => { // expect(getAngleType()).toEqual(" angle"); From 6ae03b0829561c1c6267b166a8f852b277a4a815 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 11:27:54 +0100 Subject: [PATCH 20/60] Added tests for Invalid angles --- .../rewrite-tests-with-jest/1-get-angle-type.test.js | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js index 95e1e9523..2023efed1 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js @@ -32,8 +32,8 @@ test(`should return "Right angle" when (180 < angle < 360)`, () => { expect(getAngleType(359)).toEqual("Reflex angle"); }); // Case 6: Invalid angles -// test(`should return "Right angle" when (angle = 90)`, () => { -// expect(getAngleType()).toEqual(" angle"); -// expect(getAngleType()).toEqual(" angle"); -// expect(getAngleType()).toEqual(" angle"); -// }); +test(`should return "Invalid angle" when (0 > angle > 360)`, () => { + expect(getAngleType(361)).toEqual("Invalid angle"); + expect(getAngleType(396)).toEqual("Invalid angle"); + expect(getAngleType(-57)).toEqual("Invalid angle"); +}); From 3727932b0c6b29c8ac7bcb17cae21c08f8f09037 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 12:23:40 +0100 Subject: [PATCH 21/60] Added in commented tests to update as I progress though tests. Added in test for Basic proper fraction: Numerator < Denominator --- .../2-is-proper-fraction.test.js | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index 5d49e2d8b..09d6b1394 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -6,3 +6,35 @@ import { isProperFraction } from "../implement/2-is-proper-fraction.js"; test(`should return false when denominator is zero`, () => { expect(isProperFraction(1, 0)).toEqual(false); }); + +// Special case: Basic proper fraction: Numerator < Denominator +test(`should return true when: Numerator < Denominator`, () => { + expect(isProperFraction(1, 2)).toEqual(true); + expect(isProperFraction(3, 6)).toEqual(true); + expect(isProperFraction(45, 60)).toEqual(true); +}); + +// Special case: Improper fraction: Numerator = Denominator +// test(`should return false when denominator is zero`, () => { +// expect(isProperFraction(1, 0)).toEqual(false); +// }); + +// Special case: improper fraction: Numerator > Denominator +// test(`should return false when denominator is zero`, () => { +// expect(isProperFraction(1, 0)).toEqual(false); +// }); + +// Special case: Improper fraction: Denominator = 0 +// test(`should return false when denominator is zero`, () => { +// expect(isProperFraction(1, 0)).toEqual(false); +// }); + +// Special case: Proper fraction with negative number: -Numerator < Denominator +// test(`should return false when denominator is zero`, () => { +// expect(isProperFraction(1, 0)).toEqual(false); +// }); + +// Special case: Improper fraction with negative number: -Numerator > Denominator +// test(`should return false when denominator is zero`, () => { +// expect(isProperFraction(1, 0)).toEqual(false); +// }); From 5d6c6efa34e3d3165330660a58cc2425b1ceaaeb Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 12:25:07 +0100 Subject: [PATCH 22/60] Added code for Improper fraction: Numerator = Denominator --- .../rewrite-tests-with-jest/2-is-proper-fraction.test.js | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index 09d6b1394..61756b1d2 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -15,9 +15,11 @@ test(`should return true when: Numerator < Denominator`, () => { }); // Special case: Improper fraction: Numerator = Denominator -// test(`should return false when denominator is zero`, () => { -// expect(isProperFraction(1, 0)).toEqual(false); -// }); +test(`should return false when: Numerator = Denominator`, () => { + expect(isProperFraction(1, 1)).toEqual(false); + expect(isProperFraction(12, 12)).toEqual(false); + expect(isProperFraction(56, 56)).toEqual(false); +}); // Special case: improper fraction: Numerator > Denominator // test(`should return false when denominator is zero`, () => { From b155253c033e8ca841ebfe2607c362bf6400a740 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 12:27:44 +0100 Subject: [PATCH 23/60] Added code for Improper fraction: Numerator > Denominator --- .../2-is-proper-fraction.test.js | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index 61756b1d2..2eb9a851b 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -21,10 +21,12 @@ test(`should return false when: Numerator = Denominator`, () => { expect(isProperFraction(56, 56)).toEqual(false); }); -// Special case: improper fraction: Numerator > Denominator -// test(`should return false when denominator is zero`, () => { -// expect(isProperFraction(1, 0)).toEqual(false); -// }); +// Special case: Improper fraction: Numerator > Denominator +test(`should return false when: Numerator > Denominator`, () => { + expect(isProperFraction(3, 2)).toEqual(false); + expect(isProperFraction(7, 4)).toEqual(false); + expect(isProperFraction(30, 20)).toEqual(false); +}); // Special case: Improper fraction: Denominator = 0 // test(`should return false when denominator is zero`, () => { From 6f64f2e303c09b2ffa9208ea59db6838270d4460 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 12:35:32 +0100 Subject: [PATCH 24/60] Added code for -Numerator > Denominator --- .../2-is-proper-fraction.test.js | 21 +++++++++---------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index 2eb9a851b..cbe52fd10 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -28,17 +28,16 @@ test(`should return false when: Numerator > Denominator`, () => { expect(isProperFraction(30, 20)).toEqual(false); }); -// Special case: Improper fraction: Denominator = 0 -// test(`should return false when denominator is zero`, () => { -// expect(isProperFraction(1, 0)).toEqual(false); -// }); - // Special case: Proper fraction with negative number: -Numerator < Denominator -// test(`should return false when denominator is zero`, () => { -// expect(isProperFraction(1, 0)).toEqual(false); -// }); +test(`should return true when: -Numerator < Denominator`, () => { + expect(isProperFraction(-1, 2)).toEqual(true); + expect(isProperFraction(-6, 8)).toEqual(true); + expect(isProperFraction(-10, 20)).toEqual(true); +}); // Special case: Improper fraction with negative number: -Numerator > Denominator -// test(`should return false when denominator is zero`, () => { -// expect(isProperFraction(1, 0)).toEqual(false); -// }); +test(`should return false when: -Numerator > Denominator`, () => { + expect(isProperFraction(-2, 1)).toEqual(false); + expect(isProperFraction(-5, 4)).toEqual(false); + expect(isProperFraction(-20, 10)).toEqual(false); +}); From b37a76575a710d50d1ba6c27ba2030e2ad869d4f Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 12:48:43 +0100 Subject: [PATCH 25/60] Setup code for more tests. Added code for Number cards 2-10 --- .../rewrite-tests-with-jest/3-get-card-value.test.js | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index a6de5a82a..399556059 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -9,10 +9,20 @@ test(`Should return 11 when given an ace card`, () => { // Suggestion: Group the remaining test data into these categories: // Number Cards (2-10) +test(`Should return 11 when given an ace card`, () => { + expect(getCardValue("2♠")).toEqual(2); + expect(getCardValue("7♥")).toEqual(7); + expect(getCardValue("9♦")).toEqual(9); + expect(getCardValue("5♠")).toEqual(5); +}); + // Face Cards (J, Q, K) +// test(`Should return 11 when given an ace card`, () => { +// expect(getCardValue("A♠")).toEqual(11); +// }); + // Invalid Cards // To learn how to test whether a function throws an error as expected in Jest, // please refer to the Jest documentation: // https://jestjs.io/docs/expect#tothrowerror - From 9770764ffaee61b6adce64814d090f92ff7e3b4c Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 12:51:00 +0100 Subject: [PATCH 26/60] Added code for return 10 for J, Q, K. fixed error on numbered cards. --- .../rewrite-tests-with-jest/3-get-card-value.test.js | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index 399556059..e57c9eda6 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -9,7 +9,7 @@ test(`Should return 11 when given an ace card`, () => { // Suggestion: Group the remaining test data into these categories: // Number Cards (2-10) -test(`Should return 11 when given an ace card`, () => { +test(`Should return number value when given an numbered card`, () => { expect(getCardValue("2♠")).toEqual(2); expect(getCardValue("7♥")).toEqual(7); expect(getCardValue("9♦")).toEqual(9); @@ -17,9 +17,12 @@ test(`Should return 11 when given an ace card`, () => { }); // Face Cards (J, Q, K) -// test(`Should return 11 when given an ace card`, () => { -// expect(getCardValue("A♠")).toEqual(11); -// }); +test(`Should return 10 when given a J, Q, K`, () => { + expect(getCardValue("J♠")).toEqual(10); + expect(getCardValue("Q♥")).toEqual(10); + expect(getCardValue("K♦")).toEqual(10); + expect(getCardValue("J♠")).toEqual(10); +}); // Invalid Cards From 67f4dd7feb413549b0b7dbbe082346aaedfde908 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 12:59:01 +0100 Subject: [PATCH 27/60] Added code for throw error invalid card --- .../rewrite-tests-with-jest/3-get-card-value.test.js | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index e57c9eda6..37aa69c53 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -25,7 +25,12 @@ test(`Should return 10 when given a J, Q, K`, () => { }); // Invalid Cards - +test(`Should throw error 'expected a number followed by a suit, but got "invalid"' with invalid card`, () => { + expect(getCardValue("12♥")).toThrow; + new Error('expected a number followed by a suit, but got "invalid"'); + expect(getCardValue("20♦")).toThrow; + new Error('expected a number followed by a suit, but got "invalid"'); +}); // To learn how to test whether a function throws an error as expected in Jest, // please refer to the Jest documentation: // https://jestjs.io/docs/expect#tothrowerror From 77cf05bb7852f43fdc12aa6e8cd1cfb5850cd94c Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 19:51:17 +0100 Subject: [PATCH 28/60] Added in testing code for Incorrect Suit and fixed errors with lacking () => in my thrown error tests --- .../rewrite-tests-with-jest/3-get-card-value.test.js | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index 37aa69c53..2eb1c2821 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -26,11 +26,16 @@ test(`Should return 10 when given a J, Q, K`, () => { // Invalid Cards test(`Should throw error 'expected a number followed by a suit, but got "invalid"' with invalid card`, () => { - expect(getCardValue("12♥")).toThrow; + expect(() => getCardValue("12♥")).toThrow; new Error('expected a number followed by a suit, but got "invalid"'); - expect(getCardValue("20♦")).toThrow; + expect(() => getCardValue("20♦")).toThrow; new Error('expected a number followed by a suit, but got "invalid"'); }); // To learn how to test whether a function throws an error as expected in Jest, // please refer to the Jest documentation: // https://jestjs.io/docs/expect#tothrowerror + +test(`Should throw error "Incorrect suit given" when given wrong symbol"`, () => { + expect(() => getCardValue("2☺")).toThrow; + new Error("Incorrect suit given"); +}); From 3f425542a0c493ece6d443552aecf5f716fccbdf Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 19:58:57 +0100 Subject: [PATCH 29/60] fixing erros in code and including "Incorrect card number" test --- .../3-get-card-value.test.js | 9 +++++++++ .../implement/3-get-card-value.js | 2 ++ .../rewrite-tests-with-jest/3-get-card-value.test.js | 4 ++-- 3 files changed, 13 insertions(+), 2 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index d9ad40e87..0a2ad0919 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -26,3 +26,12 @@ test("Incorrect suit", () => { "Incorrect suit" ); }); + +//Incorrect card value +test("Incorrect card number", () => { + assert.throws( + () => getCardValue("20"), + /Incorrect card number given/, + "Incorrect card number" + ); +}); diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index dca6b455d..d0645edb1 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -39,5 +39,7 @@ export function getCardValue(card) { return 11; } else if (value >= 2 && value <= 10) { return value; + } else if (Value > 10) { + throw new Error("Incorrect card number"); } } diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index 2eb1c2821..f9b2efd52 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -26,9 +26,9 @@ test(`Should return 10 when given a J, Q, K`, () => { // Invalid Cards test(`Should throw error 'expected a number followed by a suit, but got "invalid"' with invalid card`, () => { - expect(() => getCardValue("12♥")).toThrow; + expect(() => getCardValue("120♥")).toThrow; new Error('expected a number followed by a suit, but got "invalid"'); - expect(() => getCardValue("20♦")).toThrow; + expect(() => getCardValue("203♦")).toThrow; new Error('expected a number followed by a suit, but got "invalid"'); }); // To learn how to test whether a function throws an error as expected in Jest, From 328f3c16616a29653bdf95705ee142c0318ddf8e Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 9 Oct 2026 20:01:04 +0100 Subject: [PATCH 30/60] fixed errors and put in more test code for Incorrect card given --- .../implement-tests-with-node-test/3-get-card-value.test.js | 2 +- implement-and-rewrite-tests/implement/3-get-card-value.js | 2 +- .../rewrite-tests-with-jest/3-get-card-value.test.js | 5 +++++ 3 files changed, 7 insertions(+), 2 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index 0a2ad0919..ccc337afa 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -32,6 +32,6 @@ test("Incorrect card number", () => { assert.throws( () => getCardValue("20"), /Incorrect card number given/, - "Incorrect card number" + "Incorrect card number given" ); }); diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index d0645edb1..e0b63fba5 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -40,6 +40,6 @@ export function getCardValue(card) { } else if (value >= 2 && value <= 10) { return value; } else if (Value > 10) { - throw new Error("Incorrect card number"); + throw new Error("Incorrect card number given"); } } diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index f9b2efd52..323766bf0 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -39,3 +39,8 @@ test(`Should throw error "Incorrect suit given" when given wrong symbol"`, () => expect(() => getCardValue("2☺")).toThrow; new Error("Incorrect suit given"); }); + +test(`Should throw error "Incorrect card number given" when given wrong 2 digit number"`, () => { + expect(() => getCardValue("25♠")).toThrow; + new Error("Incorrect card given"); +}); From 0cca1dc1624838652e653c40924c836a699dd15c Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Sat, 10 Oct 2026 15:28:28 +0100 Subject: [PATCH 31/60] Added code and test for Full and Zero Angle. --- .../1-get-angle-type.test.js | 12 +++++++++++- .../implement/1-get-angle-type.js | 8 ++++++-- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js index 1040e57ea..e875fce67 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js @@ -32,6 +32,16 @@ test("Classifies Reflex angles", () => { }); // - "Invalid angle" for angles outside the valid range. test("Classifies Invalid angles", () => { - const right = getAngleType(360); + const right = getAngleType(361); assert.equal(right, "Invalid angle"); }); +// - "Zero angle" for angles that are at 0° +test("Classifies Invalid angles", () => { + const right = getAngleType(0); + assert.equal(right, "Zero angle"); +}); +// - "Full angle" for angles that are at 360° +test("Classifies Invalid angles", () => { + const right = getAngleType(360); + assert.equal(right, "Full angle"); +}); diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js index 9fa51c5ea..d8dabbc67 100644 --- a/implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -20,7 +20,7 @@ export function getAngleType(angle) { // TODO: Implement this function if (angle === 90) { return "Right angle"; - } else if (angle >= 0 && angle < 90) { + } else if (angle > 0 && angle < 90) { return "Acute angle"; } else if (angle > 90 && angle < 180) { return "Obtuse angle"; @@ -28,7 +28,11 @@ export function getAngleType(angle) { return "Straight angle"; } else if (angle > 180 && angle < 360) { return "Reflex angle"; - } else if (angle <= 0 || angle >= 360) { + } else if (angle === 0) { + return "Zero angle"; + } else if (angle === 360) { + return "Full angle"; + } else if (angle < 0 || angle > 360) { return "Invalid angle"; } } From 2633baa03cad80c55be37e2f25438648b207aef6 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Sat, 10 Oct 2026 15:40:02 +0100 Subject: [PATCH 32/60] Added jest tests for Zero and Full angles --- .../rewrite-tests-with-jest/1-get-angle-type.test.js | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js index 2023efed1..ade30845d 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js @@ -37,3 +37,11 @@ test(`should return "Invalid angle" when (0 > angle > 360)`, () => { expect(getAngleType(396)).toEqual("Invalid angle"); expect(getAngleType(-57)).toEqual("Invalid angle"); }); +// Case 7: Zero angles +test(`should return "Zero angle" when (angle = 0)`, () => { + expect(getAngleType(0)).toEqual("Zero angle"); +}); +// Case 8: Full angles +test(`should return "Full angle" when (angle = 360)`, () => { + expect(getAngleType(360)).toEqual("Full angle"); +}); From 9cf8fc2855eabcc9fa16c4ca37e58b6b11fb418b Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Sat, 10 Oct 2026 15:45:17 +0100 Subject: [PATCH 33/60] Added in extra invalid for negative number and fixed errors for full and zero angle. --- .../implement-tests-with-node-test/1-get-angle-type.test.js | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js index e875fce67..20e3ab4de 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js @@ -34,14 +34,16 @@ test("Classifies Reflex angles", () => { test("Classifies Invalid angles", () => { const right = getAngleType(361); assert.equal(right, "Invalid angle"); + const right = getAngleType(-361); + assert.equal(right, "Invalid angle"); }); // - "Zero angle" for angles that are at 0° -test("Classifies Invalid angles", () => { +test("Classifies Zero angles", () => { const right = getAngleType(0); assert.equal(right, "Zero angle"); }); // - "Full angle" for angles that are at 360° -test("Classifies Invalid angles", () => { +test("Classifies Full angles", () => { const right = getAngleType(360); assert.equal(right, "Full angle"); }); From 876923e6e11255836cab2f49b8c08c289a94d51c Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Sat, 10 Oct 2026 16:13:20 +0100 Subject: [PATCH 34/60] Added more negative number tests and additional improper fractions for 0 denominator. --- .../2-is-proper-fraction.test.js | 12 +++++++++++ .../implement/2-is-proper-fraction.js | 2 ++ .../2-is-proper-fraction.test.js | 21 ++++++++++++++++++- 3 files changed, 34 insertions(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js index cf534cf23..f8c131e50 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js @@ -23,10 +23,22 @@ test("Improper fraction: Denominator = 0", () => { assert.equal(isProperFraction(1, 0), false); }); +test("Improper fraction: Nominator = 0", () => { + assert.equal(isProperFraction(0, 2), false); +}); + test("Proper fraction with negative number: -Numerator < Denominator", () => { assert.equal(isProperFraction(-1, 2), true); }); +test("Proper fraction with negative number: Numerator < -Denominator", () => { + assert.equal(isProperFraction(1, -2), true); +}); + test("Improper fraction with negative number: -Numerator > Denominator", () => { assert.equal(isProperFraction(-2, 1), false); }); + +test("Proper fraction with negative numbers: -Numerator < -Denominator", () => { + assert.equal(isProperFraction(-1, -2), true); +}); diff --git a/implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/implement-and-rewrite-tests/implement/2-is-proper-fraction.js index 7b4b1f755..95a54d3be 100644 --- a/implement-and-rewrite-tests/implement/2-is-proper-fraction.js +++ b/implement-and-rewrite-tests/implement/2-is-proper-fraction.js @@ -17,6 +17,8 @@ export function isProperFraction(numerator, denominator) { // TODO: Implement this function if (denominator === 0) { return false; + } else if (numerator === 0) { + return false; } else if (Math.abs(numerator) >= Math.abs(denominator)) { return false; } diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index cbe52fd10..5d6ef14a9 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -3,10 +3,15 @@ import { isProperFraction } from "../implement/2-is-proper-fraction.js"; // TODO: Write tests in Jest syntax to cover all combinations of positives, negatives, zeros, and other categories. // Special case: numerator is zero -test(`should return false when denominator is zero`, () => { +test(`should return false when numerator is zero`, () => { expect(isProperFraction(1, 0)).toEqual(false); }); +// Special case: denominator is zero +test(`should return false when denominator is zero`, () => { + expect(isProperFraction(0, 1)).toEqual(false); +}); + // Special case: Basic proper fraction: Numerator < Denominator test(`should return true when: Numerator < Denominator`, () => { expect(isProperFraction(1, 2)).toEqual(true); @@ -14,6 +19,20 @@ test(`should return true when: Numerator < Denominator`, () => { expect(isProperFraction(45, 60)).toEqual(true); }); +// Special case: Basic proper negative fraction: -Numerator < Denominator +test(`should return true when: Numerator < Denominator`, () => { + expect(isProperFraction(-1, 2)).toEqual(true); + expect(isProperFraction(-3, 6)).toEqual(true); + expect(isProperFraction(-45, 60)).toEqual(true); +}); + +// Special case: Basic proper negative fraction: Numerator < -Denominator +test(`should return true when: Numerator < Denominator`, () => { + expect(isProperFraction(1, -2)).toEqual(true); + expect(isProperFraction(3, -6)).toEqual(true); + expect(isProperFraction(45, -60)).toEqual(true); +}); + // Special case: Improper fraction: Numerator = Denominator test(`should return false when: Numerator = Denominator`, () => { expect(isProperFraction(1, 1)).toEqual(false); From 899e43555cc862bd8c1761acf90da1544ac53e5e Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Tue, 13 Oct 2026 00:46:58 +0100 Subject: [PATCH 35/60] Changed zero and full angles to Invalid angles --- .../1-get-angle-type.test.js | 12 ++++++------ .../implement/1-get-angle-type.js | 4 ++-- .../rewrite-tests-with-jest/1-get-angle-type.test.js | 8 ++++---- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js index 20e3ab4de..136c59ff9 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js @@ -37,13 +37,13 @@ test("Classifies Invalid angles", () => { const right = getAngleType(-361); assert.equal(right, "Invalid angle"); }); -// - "Zero angle" for angles that are at 0° -test("Classifies Zero angles", () => { +// - "Invalid angle" for angles that are at 0° +test("Classifies Invalid angles for 0", () => { const right = getAngleType(0); - assert.equal(right, "Zero angle"); + assert.equal(right, "Invalid angle"); }); -// - "Full angle" for angles that are at 360° -test("Classifies Full angles", () => { +// - "Invalid angle" for angles that are at 360° +test("Classifies Invalid angles for 360", () => { const right = getAngleType(360); - assert.equal(right, "Full angle"); + assert.equal(right, "Invalid angle"); }); diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js index d8dabbc67..5a598b241 100644 --- a/implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -29,9 +29,9 @@ export function getAngleType(angle) { } else if (angle > 180 && angle < 360) { return "Reflex angle"; } else if (angle === 0) { - return "Zero angle"; + return "Invalid angle"; } else if (angle === 360) { - return "Full angle"; + return "Invalid angle"; } else if (angle < 0 || angle > 360) { return "Invalid angle"; } diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js index ade30845d..409b95982 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js @@ -38,10 +38,10 @@ test(`should return "Invalid angle" when (0 > angle > 360)`, () => { expect(getAngleType(-57)).toEqual("Invalid angle"); }); // Case 7: Zero angles -test(`should return "Zero angle" when (angle = 0)`, () => { - expect(getAngleType(0)).toEqual("Zero angle"); +test(`should return "Invalid angle" when (angle = 0)`, () => { + expect(getAngleType(0)).toEqual("Invalid angle"); }); // Case 8: Full angles -test(`should return "Full angle" when (angle = 360)`, () => { - expect(getAngleType(360)).toEqual("Full angle"); +test(`should return "Invalid angle" when (angle = 360)`, () => { + expect(getAngleType(360)).toEqual("Invalid angle"); }); From 248c2e8c7dd187aba8c5d7c772929d27ca0aebd4 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Tue, 13 Oct 2026 00:47:59 +0100 Subject: [PATCH 36/60] changed last "else if" to "else" --- implement-and-rewrite-tests/implement/1-get-angle-type.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js index 5a598b241..94e4e0f0e 100644 --- a/implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -32,7 +32,7 @@ export function getAngleType(angle) { return "Invalid angle"; } else if (angle === 360) { return "Invalid angle"; - } else if (angle < 0 || angle > 360) { + } else (angle < 0 || angle > 360) { return "Invalid angle"; } } From e6b8b53331d5269752a20b4eb52ac4d23d6dff97 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Tue, 13 Oct 2026 00:57:51 +0100 Subject: [PATCH 37/60] Added tests for 0 with negative denominator or numerator --- .../2-is-proper-fraction.test.js | 8 ++++++++ .../2-is-proper-fraction.test.js | 14 ++++++++++++++ 2 files changed, 22 insertions(+) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js index f8c131e50..7a6e97489 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js @@ -42,3 +42,11 @@ test("Improper fraction with negative number: -Numerator > Denominator", () => { test("Proper fraction with negative numbers: -Numerator < -Denominator", () => { assert.equal(isProperFraction(-1, -2), true); }); + +test("Proper fraction with negative Numerator and Zero: -Numerator < 0", () => { + assert.equal(isProperFraction(-1, 0), false); +}); + +test("Proper fraction with Zero and negative Denominator: 0 < -Denominator", () => { + assert.equal(isProperFraction(0, -2), false); +}); diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index 5d6ef14a9..6c6bf3af2 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -60,3 +60,17 @@ test(`should return false when: -Numerator > Denominator`, () => { expect(isProperFraction(-5, 4)).toEqual(false); expect(isProperFraction(-20, 10)).toEqual(false); }); + +// Special case: Improper fraction with negative Numerator and 0: -Numerator > 0 +test(`should return false when: -Numerator > Denominator`, () => { + expect(isProperFraction(-2, 0)).toEqual(false); + expect(isProperFraction(-5, 0)).toEqual(false); + expect(isProperFraction(-20, 0)).toEqual(false); +}); + +// Special case: Improper fraction with 0 and negative Denominator: 0 > -Denominator +test(`should return false when: -Numerator > Denominator`, () => { + expect(isProperFraction(0, -1)).toEqual(false); + expect(isProperFraction(0, -4)).toEqual(false); + expect(isProperFraction(0, -10)).toEqual(false); +}); From 23c6ee7987ba0f2e3f83f571ab371ed1dc0b163c Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Tue, 13 Oct 2026 01:07:05 +0100 Subject: [PATCH 38/60] made change to include any value under 1 to be Incorrect card number given. --- .../implement/3-get-card-value.js | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index e0b63fba5..6435da84c 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -25,13 +25,15 @@ export function getCardValue(card) { // TODO: Implement this function + if (card.length >= 4) { + throw new Error(`Expected a number followed by a suit, but got "invalid"`); + } + let suit = card.slice(-1); let cardNumber = card.slice(0, -1); let value = Number(cardNumber); - if (card.length >= 4) { - throw new Error(`Expected a number followed by a suit, but got "invalid"`); - } else if (!(suit === "♠" || suit === "♥" || suit === "♦" || suit === "♣")) { + if (!(suit === "♠" || suit === "♥" || suit === "♦" || suit === "♣")) { throw new Error("Incorrect suit given"); } else if (cardNumber === "J" || cardNumber === "Q" || cardNumber === "K") { return 10; @@ -39,7 +41,7 @@ export function getCardValue(card) { return 11; } else if (value >= 2 && value <= 10) { return value; - } else if (Value > 10) { + } else if (value < 2 || value > 10) { throw new Error("Incorrect card number given"); } } From 1236e2f178ea6be0ed52ac8c1aac5a3b4c257bbd Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Tue, 13 Oct 2026 01:12:45 +0100 Subject: [PATCH 39/60] Added in a if for Number.isNaN to check if for word or symbol input instead of a number value or the J Q K A --- implement-and-rewrite-tests/implement/3-get-card-value.js | 2 ++ 1 file changed, 2 insertions(+) diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index 6435da84c..2fdfd6cc6 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -39,6 +39,8 @@ export function getCardValue(card) { return 10; } else if (cardNumber === "A") { return 11; + } else if (Number.isNaN(value)) { + throw new Error("Incorrect card number given"); } else if (value >= 2 && value <= 10) { return value; } else if (value < 2 || value > 10) { From 0845379dd080beef8bd055ac368699a287d0a1a2 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Tue, 13 Oct 2026 01:22:35 +0100 Subject: [PATCH 40/60] Added tests for invalid values --- .../3-get-card-value.test.js | 30 +++++++++++++++++-- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index ccc337afa..6b3868369 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -27,10 +27,34 @@ test("Incorrect suit", () => { ); }); -//Incorrect card value -test("Incorrect card number", () => { +//Incorrect card value to high +test("Incorrect card number: High value", () => { assert.throws( - () => getCardValue("20"), + () => getCardValue("20♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); +//Incorrect card value when negative +test("Incorrect card number: Negative Number", () => { + assert.throws( + () => getCardValue("-2♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); +//Incorrect card value when symbol +test("Incorrect card number: Symbol", () => { + assert.throws( + () => getCardValue("🐱♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); +//Incorrect card value when letter +test("Incorrect card number: Letter", () => { + assert.throws( + () => getCardValue("H♦"), /Incorrect card number given/, "Incorrect card number given" ); From 0569019c0f2e56b75b253e8882d476d22e10985f Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Tue, 13 Oct 2026 01:25:22 +0100 Subject: [PATCH 41/60] Added extra jest tests for incorrect card given. --- .../3-get-card-value.test.js | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index 323766bf0..a8dd5c31d 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -44,3 +44,18 @@ test(`Should throw error "Incorrect card number given" when given wrong 2 digit expect(() => getCardValue("25♠")).toThrow; new Error("Incorrect card given"); }); + +test(`Should throw error "Incorrect card number given" when given negative number"`, () => { + expect(() => getCardValue("-2♠")).toThrow; + new Error("Incorrect card given"); +}); + +test(`Should throw error "Incorrect card number given" when given a letter"`, () => { + expect(() => getCardValue("I♠")).toThrow; + new Error("Incorrect card given"); +}); + +test(`Should throw error "Incorrect card number given" when given symbol"`, () => { + expect(() => getCardValue("🐱♠")).toThrow; + new Error("Incorrect card given"); +}); From 1a20c170ec81b5149d6f8075d519280d44079ba3 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Tue, 13 Oct 2026 01:34:18 +0100 Subject: [PATCH 42/60] fixed bug with having two tests doing - numerators. --- .../rewrite-tests-with-jest/2-is-proper-fraction.test.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index 6c6bf3af2..5a8be5157 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -54,11 +54,11 @@ test(`should return true when: -Numerator < Denominator`, () => { expect(isProperFraction(-10, 20)).toEqual(true); }); -// Special case: Improper fraction with negative number: -Numerator > Denominator +// Special case: Improper fraction with negative number: Numerator > -Denominator test(`should return false when: -Numerator > Denominator`, () => { - expect(isProperFraction(-2, 1)).toEqual(false); - expect(isProperFraction(-5, 4)).toEqual(false); - expect(isProperFraction(-20, 10)).toEqual(false); + expect(isProperFraction(2, -1)).toEqual(false); + expect(isProperFraction(5, -4)).toEqual(false); + expect(isProperFraction(20, -0)).toEqual(false); }); // Special case: Improper fraction with negative Numerator and 0: -Numerator > 0 From ba66435dd5a02031e47416433f8d4d8221886a18 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Tue, 13 Oct 2026 01:38:24 +0100 Subject: [PATCH 43/60] added both as negative test --- .../rewrite-tests-with-jest/2-is-proper-fraction.test.js | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index 5a8be5157..3fd320078 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -54,6 +54,13 @@ test(`should return true when: -Numerator < Denominator`, () => { expect(isProperFraction(-10, 20)).toEqual(true); }); +// Special case: Proper fraction with both negative number: -Numerator < -Denominator +test(`should return true when: -Numerator < -Denominator`, () => { + expect(isProperFraction(-1, -2)).toEqual(true); + expect(isProperFraction(-6, -8)).toEqual(true); + expect(isProperFraction(-10, -20)).toEqual(true); +}); + // Special case: Improper fraction with negative number: Numerator > -Denominator test(`should return false when: -Numerator > Denominator`, () => { expect(isProperFraction(2, -1)).toEqual(false); From cdd5f002c26eb39145495f3576e7a253c7b69f1e Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 14 Oct 2026 12:59:29 +0100 Subject: [PATCH 44/60] Added test for both being 0 --- .../2-is-proper-fraction.test.js | 4 ++++ .../rewrite-tests-with-jest/2-is-proper-fraction.test.js | 5 +++++ 2 files changed, 9 insertions(+) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js index 7a6e97489..dd1d41b39 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js @@ -50,3 +50,7 @@ test("Proper fraction with negative Numerator and Zero: -Numerator < 0", () => { test("Proper fraction with Zero and negative Denominator: 0 < -Denominator", () => { assert.equal(isProperFraction(0, -2), false); }); + +test("Proper fraction with both being Zero", () => { + assert.equal(isProperFraction(0, 0), false); +}); diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index 3fd320078..eb9be4df8 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -12,6 +12,11 @@ test(`should return false when denominator is zero`, () => { expect(isProperFraction(0, 1)).toEqual(false); }); +// Special case: both are zero +test(`should return false when denominator is zero`, () => { + expect(isProperFraction(0, 0)).toEqual(false); +}); + // Special case: Basic proper fraction: Numerator < Denominator test(`should return true when: Numerator < Denominator`, () => { expect(isProperFraction(1, 2)).toEqual(true); From 8b09c492c93343ad66d25ee7563e6d39697a928a Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 14 Oct 2026 13:06:51 +0100 Subject: [PATCH 45/60] Added tests missing from requests --- .../2-is-proper-fraction.test.js | 12 ++++++++++ .../2-is-proper-fraction.test.js | 23 ++++++++++++++++++- 2 files changed, 34 insertions(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js index dd1d41b39..8cffd1d99 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js @@ -15,6 +15,10 @@ test("Improper fraction: Numerator = Denominator", () => { assert.equal(isProperFraction(2, 2), false); }); +test("Improper negative fraction: Numerator = Denominator", () => { + assert.equal(isProperFraction(-2, -2), false); +}); + test("improper fraction: Numerator > Denominator", () => { assert.equal(isProperFraction(2, 1), false); }); @@ -39,6 +43,10 @@ test("Improper fraction with negative number: -Numerator > Denominator", () => { assert.equal(isProperFraction(-2, 1), false); }); +test("Improper fraction with negative number: Numerator > -Denominator", () => { + assert.equal(isProperFraction(2, -1), false); +}); + test("Proper fraction with negative numbers: -Numerator < -Denominator", () => { assert.equal(isProperFraction(-1, -2), true); }); @@ -54,3 +62,7 @@ test("Proper fraction with Zero and negative Denominator: 0 < -Denominator", () test("Proper fraction with both being Zero", () => { assert.equal(isProperFraction(0, 0), false); }); + +test("Improper fraction with negative numbers: -Numerator > -Denominator", () => { + assert.equal(isProperFraction(-3, -2), false); +}); diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index eb9be4df8..bcb3c2c83 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -45,6 +45,13 @@ test(`should return false when: Numerator = Denominator`, () => { expect(isProperFraction(56, 56)).toEqual(false); }); +// Special case: Improper negative fraction: -Numerator = -Denominator +test(`should return false when: Numerator = Denominator`, () => { + expect(isProperFraction(-1, -1)).toEqual(false); + expect(isProperFraction(-12, -12)).toEqual(false); + expect(isProperFraction(-56, -56)).toEqual(false); +}); + // Special case: Improper fraction: Numerator > Denominator test(`should return false when: Numerator > Denominator`, () => { expect(isProperFraction(3, 2)).toEqual(false); @@ -70,7 +77,21 @@ test(`should return true when: -Numerator < -Denominator`, () => { test(`should return false when: -Numerator > Denominator`, () => { expect(isProperFraction(2, -1)).toEqual(false); expect(isProperFraction(5, -4)).toEqual(false); - expect(isProperFraction(20, -0)).toEqual(false); + expect(isProperFraction(20, -10)).toEqual(false); +}); + +// Special case: Improper fraction with negative number: Numerator > -Denominator +test(`should return false when: -Numerator > Denominator`, () => { + expect(isProperFraction(-2, 1)).toEqual(false); + expect(isProperFraction(-5, 4)).toEqual(false); + expect(isProperFraction(-20, 10)).toEqual(false); +}); + +// Special case: Improper fraction with both negative: -Numerator > -Denominator +test(`should return false when: -Numerator > Denominator`, () => { + expect(isProperFraction(-2, -1)).toEqual(false); + expect(isProperFraction(-5, -4)).toEqual(false); + expect(isProperFraction(-20, -10)).toEqual(false); }); // Special case: Improper fraction with negative Numerator and 0: -Numerator > 0 From f78ab0deec65279b9ce27bc4d1c40c85e525d034 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 14 Oct 2026 14:54:51 +0100 Subject: [PATCH 46/60] Fixed spelling error in thrown error. --- implement-and-rewrite-tests/implement/3-get-card-value.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index 2fdfd6cc6..7dbba73eb 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -26,7 +26,7 @@ export function getCardValue(card) { // TODO: Implement this function if (card.length >= 4) { - throw new Error(`Expected a number followed by a suit, but got "invalid"`); + throw new Error(`expected a number followed by a suit, but got "invalid"`); } let suit = card.slice(-1); From 7046cb7b90d1075a667fee8ad96465ab8b6e9b1c Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Wed, 14 Oct 2026 14:55:44 +0100 Subject: [PATCH 47/60] Found bug in all toThrow tests, had toThrow; so was getting false positive tests. Changed to to.Throw (...) to ensure test is correct. --- .../3-get-card-value.test.js | 33 +++++++++++-------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index a8dd5c31d..073fa8743 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -26,36 +26,41 @@ test(`Should return 10 when given a J, Q, K`, () => { // Invalid Cards test(`Should throw error 'expected a number followed by a suit, but got "invalid"' with invalid card`, () => { - expect(() => getCardValue("120♥")).toThrow; - new Error('expected a number followed by a suit, but got "invalid"'); - expect(() => getCardValue("203♦")).toThrow; - new Error('expected a number followed by a suit, but got "invalid"'); + expect(() => getCardValue("120♥")).toThrow( + new Error('expected a number followed by a suit, but got "invalid"') + ); + expect(() => getCardValue("203♦")).toThrow( + new Error('expected a number followed by a suit, but got "invalid"') + ); }); // To learn how to test whether a function throws an error as expected in Jest, // please refer to the Jest documentation: // https://jestjs.io/docs/expect#tothrowerror test(`Should throw error "Incorrect suit given" when given wrong symbol"`, () => { - expect(() => getCardValue("2☺")).toThrow; - new Error("Incorrect suit given"); + expect(() => getCardValue("2☺")).toThrow(new Error("Incorrect suit given")); }); test(`Should throw error "Incorrect card number given" when given wrong 2 digit number"`, () => { - expect(() => getCardValue("25♠")).toThrow; - new Error("Incorrect card given"); + expect(() => getCardValue("25♠")).toThrow( + new Error("Incorrect card number given") + ); }); test(`Should throw error "Incorrect card number given" when given negative number"`, () => { - expect(() => getCardValue("-2♠")).toThrow; - new Error("Incorrect card given"); + expect(() => getCardValue("-2♠")).toThrow( + new Error("Incorrect card number given") + ); }); test(`Should throw error "Incorrect card number given" when given a letter"`, () => { - expect(() => getCardValue("I♠")).toThrow; - new Error("Incorrect card given"); + expect(() => getCardValue("I♠")).toThrow( + new Error("Incorrect card number given") + ); }); test(`Should throw error "Incorrect card number given" when given symbol"`, () => { - expect(() => getCardValue("🐱♠")).toThrow; - new Error("Incorrect card given"); + expect(() => getCardValue("🐱♠")).toThrow( + new Error("Incorrect card number given") + ); }); From 57ae03a87ad700c0d31fd80765ccbac839a70d02 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 16 Oct 2026 11:32:48 +0100 Subject: [PATCH 48/60] Organized order of tests to be easier to follow, added extra tests to attempt to cover all bases. 17 tests now. --- .../2-is-proper-fraction.test.js | 48 ++++++----- .../2-is-proper-fraction.test.js | 81 +++++++++++-------- 2 files changed, 74 insertions(+), 55 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js index 8cffd1d99..2677a5c15 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js @@ -11,32 +11,36 @@ test("Basic proper fraction: Numerator < Denominator", () => { assert.equal(isProperFraction(1, 2), true); }); -test("Improper fraction: Numerator = Denominator", () => { - assert.equal(isProperFraction(2, 2), false); +test("Proper fraction with negative number: -Numerator < Denominator", () => { + assert.equal(isProperFraction(-1, 2), true); }); -test("Improper negative fraction: Numerator = Denominator", () => { - assert.equal(isProperFraction(-2, -2), false); +test("Proper fraction with negative number: Numerator < -Denominator", () => { + assert.equal(isProperFraction(1, -2), true); }); -test("improper fraction: Numerator > Denominator", () => { - assert.equal(isProperFraction(2, 1), false); +test("Proper fraction with negative numbers: -Numerator < -Denominator", () => { + assert.equal(isProperFraction(-1, -2), true); }); -test("Improper fraction: Denominator = 0", () => { - assert.equal(isProperFraction(1, 0), false); +test("Improper fraction: Numerator = Denominator", () => { + assert.equal(isProperFraction(2, 2), false); }); -test("Improper fraction: Nominator = 0", () => { - assert.equal(isProperFraction(0, 2), false); +test("Improper fraction with same value and negative number: -Numerator > Denominator", () => { + assert.equal(isProperFraction(-2, 2), false); }); -test("Proper fraction with negative number: -Numerator < Denominator", () => { - assert.equal(isProperFraction(-1, 2), true); +test("Improper fraction with same value and negative number: Numerator > -Denominator", () => { + assert.equal(isProperFraction(2, -2), false); }); -test("Proper fraction with negative number: Numerator < -Denominator", () => { - assert.equal(isProperFraction(1, -2), true); +test("Improper fraction same value and both negative: Numerator = Denominator", () => { + assert.equal(isProperFraction(-2, -2), false); +}); + +test("improper fraction: Numerator > Denominator", () => { + assert.equal(isProperFraction(2, 1), false); }); test("Improper fraction with negative number: -Numerator > Denominator", () => { @@ -47,14 +51,22 @@ test("Improper fraction with negative number: Numerator > -Denominator", () => { assert.equal(isProperFraction(2, -1), false); }); -test("Proper fraction with negative numbers: -Numerator < -Denominator", () => { - assert.equal(isProperFraction(-1, -2), true); +test("Improper fraction with negative numbers: -Numerator > -Denominator", () => { + assert.equal(isProperFraction(-2, -1), false); +}); + +test("Improper fraction: Denominator = 0", () => { + assert.equal(isProperFraction(1, 0), false); }); test("Proper fraction with negative Numerator and Zero: -Numerator < 0", () => { assert.equal(isProperFraction(-1, 0), false); }); +test("Improper fraction: Nominator = 0", () => { + assert.equal(isProperFraction(0, 2), false); +}); + test("Proper fraction with Zero and negative Denominator: 0 < -Denominator", () => { assert.equal(isProperFraction(0, -2), false); }); @@ -62,7 +74,3 @@ test("Proper fraction with Zero and negative Denominator: 0 < -Denominator", () test("Proper fraction with both being Zero", () => { assert.equal(isProperFraction(0, 0), false); }); - -test("Improper fraction with negative numbers: -Numerator > -Denominator", () => { - assert.equal(isProperFraction(-3, -2), false); -}); diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js index bcb3c2c83..f28aeb5cc 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js @@ -2,21 +2,6 @@ import { isProperFraction } from "../implement/2-is-proper-fraction.js"; // TODO: Write tests in Jest syntax to cover all combinations of positives, negatives, zeros, and other categories. -// Special case: numerator is zero -test(`should return false when numerator is zero`, () => { - expect(isProperFraction(1, 0)).toEqual(false); -}); - -// Special case: denominator is zero -test(`should return false when denominator is zero`, () => { - expect(isProperFraction(0, 1)).toEqual(false); -}); - -// Special case: both are zero -test(`should return false when denominator is zero`, () => { - expect(isProperFraction(0, 0)).toEqual(false); -}); - // Special case: Basic proper fraction: Numerator < Denominator test(`should return true when: Numerator < Denominator`, () => { expect(isProperFraction(1, 2)).toEqual(true); @@ -38,62 +23,76 @@ test(`should return true when: Numerator < Denominator`, () => { expect(isProperFraction(45, -60)).toEqual(true); }); -// Special case: Improper fraction: Numerator = Denominator +// Special case: Proper fraction with both negative number: -Numerator < -Denominator +test(`should return true when: -Numerator < -Denominator`, () => { + expect(isProperFraction(-1, -2)).toEqual(true); + expect(isProperFraction(-6, -8)).toEqual(true); + expect(isProperFraction(-10, -20)).toEqual(true); +}); + +// Special case: Improper fraction when same values: Numerator = Denominator test(`should return false when: Numerator = Denominator`, () => { expect(isProperFraction(1, 1)).toEqual(false); expect(isProperFraction(12, 12)).toEqual(false); expect(isProperFraction(56, 56)).toEqual(false); }); -// Special case: Improper negative fraction: -Numerator = -Denominator +// Special case: Improper negative fraction when same values: -Numerator = -Denominator test(`should return false when: Numerator = Denominator`, () => { expect(isProperFraction(-1, -1)).toEqual(false); expect(isProperFraction(-12, -12)).toEqual(false); expect(isProperFraction(-56, -56)).toEqual(false); }); -// Special case: Improper fraction: Numerator > Denominator -test(`should return false when: Numerator > Denominator`, () => { - expect(isProperFraction(3, 2)).toEqual(false); - expect(isProperFraction(7, 4)).toEqual(false); - expect(isProperFraction(30, 20)).toEqual(false); +// Special case: Improper negative fraction when same values: -Numerator = Denominator +test(`should return false when: Numerator = Denominator`, () => { + expect(isProperFraction(-1, 1)).toEqual(false); + expect(isProperFraction(-12, 12)).toEqual(false); + expect(isProperFraction(-56, 56)).toEqual(false); }); -// Special case: Proper fraction with negative number: -Numerator < Denominator -test(`should return true when: -Numerator < Denominator`, () => { - expect(isProperFraction(-1, 2)).toEqual(true); - expect(isProperFraction(-6, 8)).toEqual(true); - expect(isProperFraction(-10, 20)).toEqual(true); +// Special case: Improper negative fraction when same values: Numerator = -Denominator +test(`should return false when: Numerator = Denominator`, () => { + expect(isProperFraction(1, -1)).toEqual(false); + expect(isProperFraction(12, -12)).toEqual(false); + expect(isProperFraction(56, -56)).toEqual(false); }); -// Special case: Proper fraction with both negative number: -Numerator < -Denominator -test(`should return true when: -Numerator < -Denominator`, () => { - expect(isProperFraction(-1, -2)).toEqual(true); - expect(isProperFraction(-6, -8)).toEqual(true); - expect(isProperFraction(-10, -20)).toEqual(true); +// Special case: Improper fraction larger Numerator: Numerator > Denominator +test(`should return false when: Numerator > Denominator`, () => { + expect(isProperFraction(3, 2)).toEqual(false); + expect(isProperFraction(7, 4)).toEqual(false); + expect(isProperFraction(30, 20)).toEqual(false); }); -// Special case: Improper fraction with negative number: Numerator > -Denominator +// Special case: Improper fraction with larger Numerator and negative Denominator: Numerator > -Denominator test(`should return false when: -Numerator > Denominator`, () => { expect(isProperFraction(2, -1)).toEqual(false); expect(isProperFraction(5, -4)).toEqual(false); expect(isProperFraction(20, -10)).toEqual(false); }); -// Special case: Improper fraction with negative number: Numerator > -Denominator +// Special case: Improper fraction with negative Numerator and larger Denominator Numerator > -Denominator test(`should return false when: -Numerator > Denominator`, () => { expect(isProperFraction(-2, 1)).toEqual(false); expect(isProperFraction(-5, 4)).toEqual(false); expect(isProperFraction(-20, 10)).toEqual(false); }); -// Special case: Improper fraction with both negative: -Numerator > -Denominator +// Special case: Improper fraction with larger Numerator and both negative: -Numerator > -Denominator test(`should return false when: -Numerator > Denominator`, () => { expect(isProperFraction(-2, -1)).toEqual(false); expect(isProperFraction(-5, -4)).toEqual(false); expect(isProperFraction(-20, -10)).toEqual(false); }); +// Special case: numerator is zero +test(`should return false when numerator is zero`, () => { + expect(isProperFraction(1, 0)).toEqual(false); + expect(isProperFraction(5, 0)).toEqual(false); + expect(isProperFraction(20, 0)).toEqual(false); +}); + // Special case: Improper fraction with negative Numerator and 0: -Numerator > 0 test(`should return false when: -Numerator > Denominator`, () => { expect(isProperFraction(-2, 0)).toEqual(false); @@ -101,9 +100,21 @@ test(`should return false when: -Numerator > Denominator`, () => { expect(isProperFraction(-20, 0)).toEqual(false); }); +// Special case: denominator is zero +test(`should return false when denominator is zero`, () => { + expect(isProperFraction(0, 1)).toEqual(false); + expect(isProperFraction(0, 4)).toEqual(false); + expect(isProperFraction(0, 10)).toEqual(false); +}); + // Special case: Improper fraction with 0 and negative Denominator: 0 > -Denominator test(`should return false when: -Numerator > Denominator`, () => { expect(isProperFraction(0, -1)).toEqual(false); expect(isProperFraction(0, -4)).toEqual(false); expect(isProperFraction(0, -10)).toEqual(false); }); + +// Special case: both are zero +test(`should return false when denominator is zero`, () => { + expect(isProperFraction(0, 0)).toEqual(false); +}); From 9154abe1113e68a597cd92158cd3fdcbaee61f54 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Fri, 16 Oct 2026 12:46:55 +0100 Subject: [PATCH 49/60] Added tests for: letter for suite - incorrect Lower case - incorrect No input --- .../3-get-card-value.test.js | 29 ++++++++++++++++++- .../implement/3-get-card-value.js | 5 ++-- .../3-get-card-value.test.js | 21 ++++++++++++++ 3 files changed, 52 insertions(+), 3 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index 6b3868369..176cc8e81 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -18,7 +18,7 @@ test("Arbitrary non-card string", () => { }); // TODO: What other invalid card cases can you think of? -//Incorrect suit +//Incorrect suit as symbol test("Incorrect suit", () => { assert.throws( () => getCardValue("2☺"), @@ -27,6 +27,15 @@ test("Incorrect suit", () => { ); }); +//Incorrect suit as letter +test("Incorrect suit", () => { + assert.throws( + () => getCardValue("7l"), + /Incorrect suit given/, + "Incorrect suit" + ); +}); + //Incorrect card value to high test("Incorrect card number: High value", () => { assert.throws( @@ -59,3 +68,21 @@ test("Incorrect card number: Letter", () => { "Incorrect card number given" ); }); + +//Incorrect card value when lower case Royal +test("Incorrect card number: lower case Royal", () => { + assert.throws( + () => getCardValue("k♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); + +//Incorrect card value when lower case Ace +test("Incorrect card number: lower case Ace", () => { + assert.throws( + () => getCardValue("a♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index 7dbba73eb..011796558 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -26,13 +26,14 @@ export function getCardValue(card) { // TODO: Implement this function if (card.length >= 4) { - throw new Error(`expected a number followed by a suit, but got "invalid"`); + throw new Error(`Expected a number followed by a suit, but got "invalid"`); + } else if (card === "") { + throw new Error("Input needed"); } let suit = card.slice(-1); let cardNumber = card.slice(0, -1); let value = Number(cardNumber); - if (!(suit === "♠" || suit === "♥" || suit === "♦" || suit === "♣")) { throw new Error("Incorrect suit given"); } else if (cardNumber === "J" || cardNumber === "Q" || cardNumber === "K") { diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index 073fa8743..55492bb4b 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -25,6 +25,7 @@ test(`Should return 10 when given a J, Q, K`, () => { }); // Invalid Cards + test(`Should throw error 'expected a number followed by a suit, but got "invalid"' with invalid card`, () => { expect(() => getCardValue("120♥")).toThrow( new Error('expected a number followed by a suit, but got "invalid"') @@ -41,6 +42,10 @@ test(`Should throw error "Incorrect suit given" when given wrong symbol"`, () => expect(() => getCardValue("2☺")).toThrow(new Error("Incorrect suit given")); }); +test(`Should throw error "Incorrect suit given" when given wrong letter"`, () => { + expect(() => getCardValue("2K")).toThrow(new Error("Incorrect suit given")); +}); + test(`Should throw error "Incorrect card number given" when given wrong 2 digit number"`, () => { expect(() => getCardValue("25♠")).toThrow( new Error("Incorrect card number given") @@ -53,6 +58,18 @@ test(`Should throw error "Incorrect card number given" when given negative numbe ); }); +test(`Should throw error "Incorrect card number given" when given a lower case Royal"`, () => { + expect(() => getCardValue("k♠")).toThrow( + new Error("Incorrect card number given") + ); +}); + +test(`Should throw error "Incorrect card number given" when given a lower case Ace"`, () => { + expect(() => getCardValue("a♠")).toThrow( + new Error("Incorrect card number given") + ); +}); + test(`Should throw error "Incorrect card number given" when given a letter"`, () => { expect(() => getCardValue("I♠")).toThrow( new Error("Incorrect card number given") @@ -64,3 +81,7 @@ test(`Should throw error "Incorrect card number given" when given symbol"`, () = new Error("Incorrect card number given") ); }); + +test(`Should throw error "Input needed" if no imput given`, () => { + expect(() => getCardValue("")).toThrow(new Error("Input needed")); +}); From 6d9296b04c338990d80c15ae39b1b259dbffca3d Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 13:28:17 +0100 Subject: [PATCH 50/60] Making adjustments of tests in order as suggested. Added in missing invalid tests. --- .../3-get-card-value.test.js | 136 ++++++++++++++---- 1 file changed, 111 insertions(+), 25 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index 176cc8e81..40f054dd2 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -5,10 +5,6 @@ import { getCardValue } from "../implement/3-get-card-value.js"; // TODO: Write tests to cover all outcomes, including throwing errors for invalid cards. -test("Valid single-digit card", () => { - assert.equal(getCardValue("9♠"), 9); -}); - test("Arbitrary non-card string", () => { assert.throws( () => getCardValue("invalid"), @@ -26,62 +22,152 @@ test("Incorrect suit", () => { "Incorrect suit" ); }); - //Incorrect suit as letter -test("Incorrect suit", () => { +//Incorrect card value to high +//Incorrect card value when negative +test("Incorrect card number: Negative Number", () => { + assert.throws( + () => getCardValue("-2♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); + +//Incorrect card value when symbol +//Incorrect card value when letter +test("Incorrect card number: Letter", () => { + assert.throws( + () => getCardValue("H♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); + +//Incorrect card value when lower case Royal +test("Incorrect card number: lower case Royal", () => { + assert.throws( + () => getCardValue("k♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); + +//Incorrect card value when lower case Ace +test("Incorrect card number: lower case Ace", () => { + assert.throws( + () => getCardValue("a♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); + +// for valid case: +// any of 2-9 (single digit number) with valid suit +test("Valid single-digit card", () => { + assert.equal(getCardValue("9♠"), 9); +}); + +// number 10 (double digit number) with valid suit + +// J/Q/K with valid suit (because they should return 10) + +// A with valid suit (because it should specially return 11) + +// for invalid case: + +// 1 (single digit number) with valid suit +test("Incorrect face valuev of 1: 1♦ ", () => { + assert.throws( + () => getCardValue("1♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); + +// 11 (special double digit number) with valid suit +test("Incorrect face value of 11: 11♦", () => { + assert.throws( + () => getCardValue("11♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); + +// any of 12-99 (double digit number) with valid suit +test("Incorrect face value given: 11-99♦", () => { + assert.throws( + () => getCardValue("20♦"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); + +// any B-Z except J/Q/K with valid suit +test("Incorrect royal face given: 7L", () => { assert.throws( - () => getCardValue("7l"), + () => getCardValue("7L"), /Incorrect suit given/, "Incorrect suit" ); }); -//Incorrect card value to high -test("Incorrect card number: High value", () => { +// any invalid face with valid suit +test("Incorrect face given: 🐱♦", () => { assert.throws( - () => getCardValue("20♦"), + () => getCardValue("🐱♦"), /Incorrect card number given/, "Incorrect card number given" ); }); -//Incorrect card value when negative -test("Incorrect card number: Negative Number", () => { + +// valid suit with valid face (e.g. "♦6") +test("Incorrect order of face and suit: ", () => { assert.throws( - () => getCardValue("-2♦"), + () => getCardValue("♦6"), /Incorrect card number given/, "Incorrect card number given" ); }); -//Incorrect card value when symbol -test("Incorrect card number: Symbol", () => { +// any invalid face with any invalid suit +test("Invalid face and suit: 🐱🐱", () => { assert.throws( - () => getCardValue("🐱♦"), + () => getCardValue("🐱🐱"), /Incorrect card number given/, "Incorrect card number given" ); }); -//Incorrect card value when letter -test("Incorrect card number: Letter", () => { + +// any of 2-9 (valid single digit number) with invalid suit +test("Incorrect 2-9 card suit: 2🐱", () => { assert.throws( - () => getCardValue("H♦"), + () => getCardValue("2🐱"), /Incorrect card number given/, "Incorrect card number given" ); }); -//Incorrect card value when lower case Royal -test("Incorrect card number: lower case Royal", () => { +// number 10 (valid double digit number) with invalid suit +test("Incorrect 10 card suit: 10🐱", () => { assert.throws( - () => getCardValue("k♦"), + () => getCardValue("10🐱"), /Incorrect card number given/, "Incorrect card number given" ); }); -//Incorrect card value when lower case Ace -test("Incorrect card number: lower case Ace", () => { +// J/Q/K with invalid suit +test("Incorrect J/Q/K card suit: K🐱", () => { assert.throws( - () => getCardValue("a♦"), + () => getCardValue("K🐱"), + /Incorrect card number given/, + "Incorrect card number given" + ); +}); + +// A with invalid suit +test("Incorrect A card suit: A🐱", () => { + assert.throws( + () => getCardValue("A🐱"), /Incorrect card number given/, "Incorrect card number given" ); From a2ea4211a99418c06ef8f33c2c420b48d7dc8117 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 13:47:04 +0100 Subject: [PATCH 51/60] Made changes to first error so it throws Invalid on Arbitrary non-card string. Checking each test to ensure accurate. --- .../3-get-card-value.test.js | 282 +++++++++--------- .../implement/3-get-card-value.js | 2 +- 2 files changed, 142 insertions(+), 142 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index 40f054dd2..964b057ab 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -8,8 +8,8 @@ import { getCardValue } from "../implement/3-get-card-value.js"; test("Arbitrary non-card string", () => { assert.throws( () => getCardValue("invalid"), - /Expected a number followed by a suit, but got "invalid"/, - "Expected clear error" + /Invalid/, + "Arbitary non-card string gives: Invalid" ); }); @@ -33,142 +33,142 @@ test("Incorrect card number: Negative Number", () => { ); }); -//Incorrect card value when symbol -//Incorrect card value when letter -test("Incorrect card number: Letter", () => { - assert.throws( - () => getCardValue("H♦"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -//Incorrect card value when lower case Royal -test("Incorrect card number: lower case Royal", () => { - assert.throws( - () => getCardValue("k♦"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -//Incorrect card value when lower case Ace -test("Incorrect card number: lower case Ace", () => { - assert.throws( - () => getCardValue("a♦"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -// for valid case: -// any of 2-9 (single digit number) with valid suit -test("Valid single-digit card", () => { - assert.equal(getCardValue("9♠"), 9); -}); - -// number 10 (double digit number) with valid suit - -// J/Q/K with valid suit (because they should return 10) - -// A with valid suit (because it should specially return 11) - -// for invalid case: - -// 1 (single digit number) with valid suit -test("Incorrect face valuev of 1: 1♦ ", () => { - assert.throws( - () => getCardValue("1♦"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -// 11 (special double digit number) with valid suit -test("Incorrect face value of 11: 11♦", () => { - assert.throws( - () => getCardValue("11♦"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -// any of 12-99 (double digit number) with valid suit -test("Incorrect face value given: 11-99♦", () => { - assert.throws( - () => getCardValue("20♦"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -// any B-Z except J/Q/K with valid suit -test("Incorrect royal face given: 7L", () => { - assert.throws( - () => getCardValue("7L"), - /Incorrect suit given/, - "Incorrect suit" - ); -}); - -// any invalid face with valid suit -test("Incorrect face given: 🐱♦", () => { - assert.throws( - () => getCardValue("🐱♦"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -// valid suit with valid face (e.g. "♦6") -test("Incorrect order of face and suit: ", () => { - assert.throws( - () => getCardValue("♦6"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); -// any invalid face with any invalid suit -test("Invalid face and suit: 🐱🐱", () => { - assert.throws( - () => getCardValue("🐱🐱"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -// any of 2-9 (valid single digit number) with invalid suit -test("Incorrect 2-9 card suit: 2🐱", () => { - assert.throws( - () => getCardValue("2🐱"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -// number 10 (valid double digit number) with invalid suit -test("Incorrect 10 card suit: 10🐱", () => { - assert.throws( - () => getCardValue("10🐱"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -// J/Q/K with invalid suit -test("Incorrect J/Q/K card suit: K🐱", () => { - assert.throws( - () => getCardValue("K🐱"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); - -// A with invalid suit -test("Incorrect A card suit: A🐱", () => { - assert.throws( - () => getCardValue("A🐱"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); +// //Incorrect card value when symbol +// //Incorrect card value when letter +// test("Incorrect card number: Letter", () => { +// assert.throws( +// () => getCardValue("H♦"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// //Incorrect card value when lower case Royal +// test("Incorrect card number: lower case Royal", () => { +// assert.throws( +// () => getCardValue("k♦"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// //Incorrect card value when lower case Ace +// test("Incorrect card number: lower case Ace", () => { +// assert.throws( +// () => getCardValue("a♦"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// // for valid case: +// // any of 2-9 (single digit number) with valid suit +// test("Valid single-digit card", () => { +// assert.equal(getCardValue("9♠"), 9); +// }); + +// // number 10 (double digit number) with valid suit + +// // J/Q/K with valid suit (because they should return 10) + +// // A with valid suit (because it should specially return 11) + +// // for invalid case: + +// // 1 (single digit number) with valid suit +// test("Incorrect face valuev of 1: 1♦ ", () => { +// assert.throws( +// () => getCardValue("1♦"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// // 11 (special double digit number) with valid suit +// test("Incorrect face value of 11: 11♦", () => { +// assert.throws( +// () => getCardValue("11♦"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// // any of 12-99 (double digit number) with valid suit +// test("Incorrect face value given: 11-99♦", () => { +// assert.throws( +// () => getCardValue("20♦"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// // any B-Z except J/Q/K with valid suit +// test("Incorrect royal face given: 7L", () => { +// assert.throws( +// () => getCardValue("7L"), +// /Incorrect suit given/, +// "Incorrect suit" +// ); +// }); + +// // any invalid face with valid suit +// test("Incorrect face given: 🐱♦", () => { +// assert.throws( +// () => getCardValue("🐱♦"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// // valid suit with valid face (e.g. "♦6") +// test("Incorrect order of face and suit: ", () => { +// assert.throws( +// () => getCardValue("♦6"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); +// // any invalid face with any invalid suit +// test("Invalid face and suit: 🐱🐱", () => { +// assert.throws( +// () => getCardValue("🐱🐱"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// // any of 2-9 (valid single digit number) with invalid suit +// test("Incorrect 2-9 card suit: 2🐱", () => { +// assert.throws( +// () => getCardValue("2🐱"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// // number 10 (valid double digit number) with invalid suit +// test("Incorrect 10 card suit: 10🐱", () => { +// assert.throws( +// () => getCardValue("10🐱"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// // J/Q/K with invalid suit +// test("Incorrect J/Q/K card suit: K🐱", () => { +// assert.throws( +// () => getCardValue("K🐱"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); + +// // A with invalid suit +// test("Incorrect A card suit: A🐱", () => { +// assert.throws( +// () => getCardValue("A🐱"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index 011796558..05d94f815 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -26,7 +26,7 @@ export function getCardValue(card) { // TODO: Implement this function if (card.length >= 4) { - throw new Error(`Expected a number followed by a suit, but got "invalid"`); + throw new Error("Invalid"); } else if (card === "") { throw new Error("Input needed"); } From bf56576935b5dd5cf7b15174545caebfe3b15433 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 14:05:09 +0100 Subject: [PATCH 52/60] Valid cards testing completed --- .../3-get-card-value.test.js | 54 +++++++++++-------- 1 file changed, 32 insertions(+), 22 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index 964b057ab..2ea3a4966 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -15,23 +15,24 @@ test("Arbitrary non-card string", () => { // TODO: What other invalid card cases can you think of? //Incorrect suit as symbol -test("Incorrect suit", () => { - assert.throws( - () => getCardValue("2☺"), - /Incorrect suit given/, - "Incorrect suit" - ); -}); -//Incorrect suit as letter -//Incorrect card value to high -//Incorrect card value when negative -test("Incorrect card number: Negative Number", () => { - assert.throws( - () => getCardValue("-2♦"), - /Incorrect card number given/, - "Incorrect card number given" - ); -}); +// test("Incorrect suit", () => { +// assert.throws( +// () => getCardValue("2☺"), +// /Incorrect suit given/, +// "Incorrect suit" +// ); +// }); +// //Incorrect suit as letter +// //Incorrect card value to high + +// //Incorrect card value when negative +// test("Incorrect card number: Negative Number", () => { +// assert.throws( +// () => getCardValue("-2♦"), +// /Incorrect card number given/, +// "Incorrect card number given" +// ); +// }); // //Incorrect card value when symbol // //Incorrect card value when letter @@ -61,17 +62,26 @@ test("Incorrect card number: Negative Number", () => { // ); // }); -// // for valid case: -// // any of 2-9 (single digit number) with valid suit -// test("Valid single-digit card", () => { -// assert.equal(getCardValue("9♠"), 9); -// }); +// for valid case: +// any of 2-9 (single digit number) with valid suit +test("Valid single-digit face card", () => { + assert.equal(getCardValue("9♠"), 9); +}); // // number 10 (double digit number) with valid suit +test("Valid double-digit face card", () => { + assert.equal(getCardValue("10♠"), 10); +}); // // J/Q/K with valid suit (because they should return 10) +test("Valid Royal face card", () => { + assert.equal(getCardValue("Q♠"), 10); +}); // // A with valid suit (because it should specially return 11) +test("Valid Ace face card", () => { + assert.equal(getCardValue("A♠"), 11); +}); // // for invalid case: From 4a80e95c2faa492b9c8d7172cf4393067466d3fa Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 14:09:09 +0100 Subject: [PATCH 53/60] changed "incorrect card number given" to "Incorrect face given" --- .../3-get-card-value.test.js | 120 +++++++++--------- .../implement/3-get-card-value.js | 4 +- 2 files changed, 62 insertions(+), 62 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index 2ea3a4966..ebe7c744d 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -29,8 +29,8 @@ test("Arbitrary non-card string", () => { // test("Incorrect card number: Negative Number", () => { // assert.throws( // () => getCardValue("-2♦"), -// /Incorrect card number given/, -// "Incorrect card number given" +// /Incorrect face given/, +// "Incorrect face given" // ); // }); @@ -39,8 +39,8 @@ test("Arbitrary non-card string", () => { // test("Incorrect card number: Letter", () => { // assert.throws( // () => getCardValue("H♦"), -// /Incorrect card number given/, -// "Incorrect card number given" +// /Incorrect face given/, +// "Incorrect face given" // ); // }); @@ -48,8 +48,8 @@ test("Arbitrary non-card string", () => { // test("Incorrect card number: lower case Royal", () => { // assert.throws( // () => getCardValue("k♦"), -// /Incorrect card number given/, -// "Incorrect card number given" +// /Incorrect face given/, +// "Incorrect face given" // ); // }); @@ -57,8 +57,8 @@ test("Arbitrary non-card string", () => { // test("Incorrect card number: lower case Ace", () => { // assert.throws( // () => getCardValue("a♦"), -// /Incorrect card number given/, -// "Incorrect card number given" +// /Incorrect face given/, +// "Incorrect face given" // ); // }); @@ -85,65 +85,65 @@ test("Valid Ace face card", () => { // // for invalid case: -// // 1 (single digit number) with valid suit -// test("Incorrect face valuev of 1: 1♦ ", () => { -// assert.throws( -// () => getCardValue("1♦"), -// /Incorrect card number given/, -// "Incorrect card number given" -// ); -// }); +// 1 (single digit number) with valid suit +test("Incorrect face valuev of 1: 1♦ ", () => { + assert.throws( + () => getCardValue("1♦"), + /Incorrect face given/, + "Incorrect face given" + ); +}); -// // 11 (special double digit number) with valid suit -// test("Incorrect face value of 11: 11♦", () => { -// assert.throws( -// () => getCardValue("11♦"), -// /Incorrect card number given/, -// "Incorrect card number given" -// ); -// }); +// 11 (special double digit number) with valid suit +test("Incorrect face value of 11: 11♦", () => { + assert.throws( + () => getCardValue("11♦"), + /Incorrect face given/, + "Incorrect face given" + ); +}); -// // any of 12-99 (double digit number) with valid suit -// test("Incorrect face value given: 11-99♦", () => { -// assert.throws( -// () => getCardValue("20♦"), -// /Incorrect card number given/, -// "Incorrect card number given" -// ); -// }); +// any of 12-99 (double digit number) with valid suit +test("Incorrect face value given: 11-99♦", () => { + assert.throws( + () => getCardValue("20♦"), + /Incorrect face given/, + "Incorrect face given" + ); +}); -// // any B-Z except J/Q/K with valid suit -// test("Incorrect royal face given: 7L", () => { -// assert.throws( -// () => getCardValue("7L"), -// /Incorrect suit given/, -// "Incorrect suit" -// ); -// }); +// any B-Z except J/Q/K with valid suit +test("Incorrect royal face given: 7L", () => { + assert.throws( + () => getCardValue("7L"), + /Incorrect suit given/, + "Incorrect suit" + ); +}); -// // any invalid face with valid suit -// test("Incorrect face given: 🐱♦", () => { -// assert.throws( -// () => getCardValue("🐱♦"), -// /Incorrect card number given/, -// "Incorrect card number given" -// ); -// }); +// any invalid face with valid suit +test("Incorrect face given: 🐱♦", () => { + assert.throws( + () => getCardValue("🐱♦"), + /Incorrect face given/, + "Incorrect face given" + ); +}); // // valid suit with valid face (e.g. "♦6") // test("Incorrect order of face and suit: ", () => { // assert.throws( // () => getCardValue("♦6"), -// /Incorrect card number given/, -// "Incorrect card number given" +// /Incorrect face given/, +// "Incorrect face given" // ); // }); // // any invalid face with any invalid suit // test("Invalid face and suit: 🐱🐱", () => { // assert.throws( // () => getCardValue("🐱🐱"), -// /Incorrect card number given/, -// "Incorrect card number given" +// /Incorrect face given/, +// "Incorrect face given" // ); // }); @@ -151,8 +151,8 @@ test("Valid Ace face card", () => { // test("Incorrect 2-9 card suit: 2🐱", () => { // assert.throws( // () => getCardValue("2🐱"), -// /Incorrect card number given/, -// "Incorrect card number given" +// /Incorrect face given/, +// "Incorrect face given" // ); // }); @@ -160,8 +160,8 @@ test("Valid Ace face card", () => { // test("Incorrect 10 card suit: 10🐱", () => { // assert.throws( // () => getCardValue("10🐱"), -// /Incorrect card number given/, -// "Incorrect card number given" +// /Incorrect face given/, +// "Incorrect face given" // ); // }); @@ -169,8 +169,8 @@ test("Valid Ace face card", () => { // test("Incorrect J/Q/K card suit: K🐱", () => { // assert.throws( // () => getCardValue("K🐱"), -// /Incorrect card number given/, -// "Incorrect card number given" +// /Incorrect face given/, +// "Incorrect face given" // ); // }); @@ -178,7 +178,7 @@ test("Valid Ace face card", () => { // test("Incorrect A card suit: A🐱", () => { // assert.throws( // () => getCardValue("A🐱"), -// /Incorrect card number given/, -// "Incorrect card number given" +// /Incorrect face given/, +// "Incorrect face given" // ); // }); diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index 05d94f815..2f8adbf6e 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -41,10 +41,10 @@ export function getCardValue(card) { } else if (cardNumber === "A") { return 11; } else if (Number.isNaN(value)) { - throw new Error("Incorrect card number given"); + throw new Error("Incorrect face given"); } else if (value >= 2 && value <= 10) { return value; } else if (value < 2 || value > 10) { - throw new Error("Incorrect card number given"); + throw new Error("Incorrect face given"); } } From 105d594aeff9372a8eff1b8820f073bb88739654 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 14:24:37 +0100 Subject: [PATCH 54/60] Done all tests for node-test --- .../3-get-card-value.test.js | 195 ++++++++---------- .../implement/3-get-card-value.js | 6 +- 2 files changed, 94 insertions(+), 107 deletions(-) diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js index ebe7c744d..bb643d3e3 100644 --- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js @@ -13,55 +13,6 @@ test("Arbitrary non-card string", () => { ); }); -// TODO: What other invalid card cases can you think of? -//Incorrect suit as symbol -// test("Incorrect suit", () => { -// assert.throws( -// () => getCardValue("2☺"), -// /Incorrect suit given/, -// "Incorrect suit" -// ); -// }); -// //Incorrect suit as letter -// //Incorrect card value to high - -// //Incorrect card value when negative -// test("Incorrect card number: Negative Number", () => { -// assert.throws( -// () => getCardValue("-2♦"), -// /Incorrect face given/, -// "Incorrect face given" -// ); -// }); - -// //Incorrect card value when symbol -// //Incorrect card value when letter -// test("Incorrect card number: Letter", () => { -// assert.throws( -// () => getCardValue("H♦"), -// /Incorrect face given/, -// "Incorrect face given" -// ); -// }); - -// //Incorrect card value when lower case Royal -// test("Incorrect card number: lower case Royal", () => { -// assert.throws( -// () => getCardValue("k♦"), -// /Incorrect face given/, -// "Incorrect face given" -// ); -// }); - -// //Incorrect card value when lower case Ace -// test("Incorrect card number: lower case Ace", () => { -// assert.throws( -// () => getCardValue("a♦"), -// /Incorrect face given/, -// "Incorrect face given" -// ); -// }); - // for valid case: // any of 2-9 (single digit number) with valid suit test("Valid single-digit face card", () => { @@ -83,10 +34,9 @@ test("Valid Ace face card", () => { assert.equal(getCardValue("A♠"), 11); }); -// // for invalid case: - +// for invalid case: // 1 (single digit number) with valid suit -test("Incorrect face valuev of 1: 1♦ ", () => { +test("Incorrect face value of 1: 1♦ ", () => { assert.throws( () => getCardValue("1♦"), /Incorrect face given/, @@ -130,55 +80,92 @@ test("Incorrect face given: 🐱♦", () => { ); }); -// // valid suit with valid face (e.g. "♦6") -// test("Incorrect order of face and suit: ", () => { -// assert.throws( -// () => getCardValue("♦6"), -// /Incorrect face given/, -// "Incorrect face given" -// ); -// }); -// // any invalid face with any invalid suit -// test("Invalid face and suit: 🐱🐱", () => { -// assert.throws( -// () => getCardValue("🐱🐱"), -// /Incorrect face given/, -// "Incorrect face given" -// ); -// }); - -// // any of 2-9 (valid single digit number) with invalid suit -// test("Incorrect 2-9 card suit: 2🐱", () => { -// assert.throws( -// () => getCardValue("2🐱"), -// /Incorrect face given/, -// "Incorrect face given" -// ); -// }); - -// // number 10 (valid double digit number) with invalid suit -// test("Incorrect 10 card suit: 10🐱", () => { -// assert.throws( -// () => getCardValue("10🐱"), -// /Incorrect face given/, -// "Incorrect face given" -// ); -// }); - -// // J/Q/K with invalid suit -// test("Incorrect J/Q/K card suit: K🐱", () => { -// assert.throws( -// () => getCardValue("K🐱"), -// /Incorrect face given/, -// "Incorrect face given" -// ); -// }); - -// // A with invalid suit -// test("Incorrect A card suit: A🐱", () => { -// assert.throws( -// () => getCardValue("A🐱"), -// /Incorrect face given/, -// "Incorrect face given" -// ); -// }); +// valid suit with valid face (e.g. "♦6") +test("Incorrect order of face and suit: ", () => { + assert.throws( + () => getCardValue("♦6"), + /Incorrect suit given/, + "Incorrect suit given" + ); +}); + +// any invalid face with any invalid suit +test("Invalid face and suit: 🐱🐱", () => { + assert.throws( + () => getCardValue("🐱🐱"), + /Incorrect suit given/, + "Incorrect suit given" + ); +}); + +// any of 2-9 (valid single digit number) with invalid suit +test("Incorrect 2-9 card suit: 2🐱", () => { + assert.throws( + () => getCardValue("2🐱"), + /Incorrect suit given/, + "Incorrect suit given" + ); +}); + +// number 10 (valid double digit number) with invalid suit +test("Incorrect 10 card suit: 10🐱", () => { + assert.throws( + () => getCardValue("10🐱"), + /Incorrect suit given/, + "Incorrect suit given" + ); +}); + +// J/Q/K with invalid suit +test("Incorrect J/Q/K card suit: K🐱", () => { + assert.throws( + () => getCardValue("K🐱"), + /Incorrect suit given/, + "Incorrect suit given" + ); +}); + +// A with invalid suit +test("Incorrect A card suit: A🐱", () => { + assert.throws( + () => getCardValue("A🐱"), + /Incorrect suit given/, + "Incorrect suit given" + ); +}); + +//Incorrect card value when letter +test("Incorrect card number: Letter", () => { + assert.throws( + () => getCardValue("H♦"), + /Incorrect face given/, + "Incorrect face given" + ); +}); + +//Incorrect card value when lower case Royal +test("Incorrect card number: lower case Royal", () => { + assert.throws( + () => getCardValue("k♦"), + /Incorrect face given/, + "Incorrect face given" + ); +}); + +//Incorrect card value when lower case Ace +test("Incorrect card number: lower case Ace", () => { + assert.throws( + () => getCardValue("a♦"), + /Incorrect face given/, + "Incorrect face given" + ); +}); + +//Incorrect card value when negative +test("Incorrect card number: Negative Number", () => { + assert.throws( + () => getCardValue("-2♦"), + /Incorrect face given/, + "Incorrect face given" + ); +}); diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js index 2f8adbf6e..84bfede52 100644 --- a/implement-and-rewrite-tests/implement/3-get-card-value.js +++ b/implement-and-rewrite-tests/implement/3-get-card-value.js @@ -25,10 +25,10 @@ export function getCardValue(card) { // TODO: Implement this function - if (card.length >= 4) { - throw new Error("Invalid"); - } else if (card === "") { + if (card === "") { throw new Error("Input needed"); + } else if (card.length >= 5) { + throw new Error("Invalid"); } let suit = card.slice(-1); From c54a4c1dfc8bacd9d8a56f685719491ea8d7cecc Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 14:37:38 +0100 Subject: [PATCH 55/60] Started organizing jest tests --- .../3-get-card-value.test.js | 145 +++++++++--------- 1 file changed, 76 insertions(+), 69 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index 55492bb4b..64a44bb0b 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -2,86 +2,93 @@ import { getCardValue } from "../implement/3-get-card-value.js"; // TODO: Write tests in Jest syntax to cover all possible outcomes. -// Case 1: Ace (A) -test(`Should return 11 when given an ace card`, () => { - expect(getCardValue("A♠")).toEqual(11); -}); +// // Suggestion: Group the remaining test data into these categories: +// // Number Cards (2-10) +// test(`Should return number value when given an numbered card`, () => { +// expect(getCardValue("2♠")).toEqual(2); +// expect(getCardValue("7♥")).toEqual(7); +// expect(getCardValue("9♦")).toEqual(9); +// expect(getCardValue("5♠")).toEqual(5); +// }); -// Suggestion: Group the remaining test data into these categories: -// Number Cards (2-10) -test(`Should return number value when given an numbered card`, () => { - expect(getCardValue("2♠")).toEqual(2); - expect(getCardValue("7♥")).toEqual(7); - expect(getCardValue("9♦")).toEqual(9); - expect(getCardValue("5♠")).toEqual(5); -}); +// // Face Cards (J, Q, K) +// test(`Should return 10 when given a J, Q, K`, () => { +// expect(getCardValue("J♠")).toEqual(10); +// expect(getCardValue("Q♥")).toEqual(10); +// expect(getCardValue("K♦")).toEqual(10); +// expect(getCardValue("J♠")).toEqual(10); +// }); -// Face Cards (J, Q, K) -test(`Should return 10 when given a J, Q, K`, () => { - expect(getCardValue("J♠")).toEqual(10); - expect(getCardValue("Q♥")).toEqual(10); - expect(getCardValue("K♦")).toEqual(10); - expect(getCardValue("J♠")).toEqual(10); -}); +// // Invalid Cards -// Invalid Cards +// test(`Should throw error 'expected a number followed by a suit, but got "invalid"' with invalid card`, () => { +// expect(() => getCardValue("120♥")).toThrow( +// new Error('expected a number followed by a suit, but got "invalid"') +// ); +// expect(() => getCardValue("203♦")).toThrow( +// new Error('expected a number followed by a suit, but got "invalid"') +// ); +// }); +// // To learn how to test whether a function throws an error as expected in Jest, +// // please refer to the Jest documentation: +// // https://jestjs.io/docs/expect#tothrowerror -test(`Should throw error 'expected a number followed by a suit, but got "invalid"' with invalid card`, () => { - expect(() => getCardValue("120♥")).toThrow( - new Error('expected a number followed by a suit, but got "invalid"') - ); - expect(() => getCardValue("203♦")).toThrow( - new Error('expected a number followed by a suit, but got "invalid"') - ); -}); -// To learn how to test whether a function throws an error as expected in Jest, -// please refer to the Jest documentation: -// https://jestjs.io/docs/expect#tothrowerror +// test(`Should throw error "Incorrect suit given" when given wrong symbol"`, () => { +// expect(() => getCardValue("2☺")).toThrow(new Error("Incorrect suit given")); +// }); -test(`Should throw error "Incorrect suit given" when given wrong symbol"`, () => { - expect(() => getCardValue("2☺")).toThrow(new Error("Incorrect suit given")); -}); +// test(`Should throw error "Incorrect suit given" when given wrong letter"`, () => { +// expect(() => getCardValue("2K")).toThrow(new Error("Incorrect suit given")); +// }); -test(`Should throw error "Incorrect suit given" when given wrong letter"`, () => { - expect(() => getCardValue("2K")).toThrow(new Error("Incorrect suit given")); -}); +// test(`Should throw error "Incorrect face given" when given wrong 2 digit number"`, () => { +// expect(() => getCardValue("25♠")).toThrow(new Error("Incorrect face given")); +// }); -test(`Should throw error "Incorrect card number given" when given wrong 2 digit number"`, () => { - expect(() => getCardValue("25♠")).toThrow( - new Error("Incorrect card number given") - ); -}); +// test(`Should throw error "Incorrect face given" when given negative number"`, () => { +// expect(() => getCardValue("-2♠")).toThrow(new Error("Incorrect face given")); +// }); -test(`Should throw error "Incorrect card number given" when given negative number"`, () => { - expect(() => getCardValue("-2♠")).toThrow( - new Error("Incorrect card number given") - ); -}); +// test(`Should throw error "Incorrect face given" when given a lower case Royal"`, () => { +// expect(() => getCardValue("k♠")).toThrow(new Error("Incorrect face given")); +// }); -test(`Should throw error "Incorrect card number given" when given a lower case Royal"`, () => { - expect(() => getCardValue("k♠")).toThrow( - new Error("Incorrect card number given") - ); -}); +// test(`Should throw error "Incorrect face given" when given a lower case Ace"`, () => { +// expect(() => getCardValue("a♠")).toThrow(new Error("Incorrect face given")); +// }); -test(`Should throw error "Incorrect card number given" when given a lower case Ace"`, () => { - expect(() => getCardValue("a♠")).toThrow( - new Error("Incorrect card number given") - ); -}); +// test(`Should throw error "Incorrect face given" when given a letter"`, () => { +// expect(() => getCardValue("I♠")).toThrow(new Error("Incorrect face given")); +// }); -test(`Should throw error "Incorrect card number given" when given a letter"`, () => { - expect(() => getCardValue("I♠")).toThrow( - new Error("Incorrect card number given") - ); -}); +// test(`Should throw error "Incorrect face given" when given symbol"`, () => { +// expect(() => getCardValue("🐱♠")).toThrow(new Error("Incorrect face given")); +// }); -test(`Should throw error "Incorrect card number given" when given symbol"`, () => { - expect(() => getCardValue("🐱♠")).toThrow( - new Error("Incorrect card number given") - ); -}); +// test(`Should throw error "Input needed" if no imput given`, () => { +// expect(() => getCardValue("")).toThrow(new Error("Input needed")); +// }); -test(`Should throw error "Input needed" if no imput given`, () => { - expect(() => getCardValue("")).toThrow(new Error("Input needed")); +// for valid case: + +// any of 2-9 (single digit number) with valid suit +// number 10 (double digit number) with valid suit +// J/Q/K with valid suit (because they should return 10) +// A with valid suit (because it should specially return 11) +// Case 1: Ace (A) +test(`Should return 11 when given an ace card`, () => { + expect(getCardValue("A♠")).toEqual(11); }); +// for invalid case: + +// 1 (single digit number) with valid suit +// 11 (special double digit number) with valid suit +// any of 12-99 (double digit number) with valid suit +// any B-Z except J/Q/K with valid suit +// any invalid face with valid suit +// valid suit with valid face (e.g. "♠9") +// any invalid face with any invalid suit +// any of 2-9 (valid single digit number) with invalid suit +// number 10 (valid double digit number) with invalid suit +// J/Q/K with invalid suit +// A with invalid suit From b5f439a3f8a4c10e1160f1beac99e6da20d9ebf8 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 14:40:52 +0100 Subject: [PATCH 56/60] Tests done for valid cards --- .../3-get-card-value.test.js | 38 +++++++++---------- 1 file changed, 18 insertions(+), 20 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index 64a44bb0b..b45dc071a 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -1,24 +1,5 @@ import { getCardValue } from "../implement/3-get-card-value.js"; -// TODO: Write tests in Jest syntax to cover all possible outcomes. - -// // Suggestion: Group the remaining test data into these categories: -// // Number Cards (2-10) -// test(`Should return number value when given an numbered card`, () => { -// expect(getCardValue("2♠")).toEqual(2); -// expect(getCardValue("7♥")).toEqual(7); -// expect(getCardValue("9♦")).toEqual(9); -// expect(getCardValue("5♠")).toEqual(5); -// }); - -// // Face Cards (J, Q, K) -// test(`Should return 10 when given a J, Q, K`, () => { -// expect(getCardValue("J♠")).toEqual(10); -// expect(getCardValue("Q♥")).toEqual(10); -// expect(getCardValue("K♦")).toEqual(10); -// expect(getCardValue("J♠")).toEqual(10); -// }); - // // Invalid Cards // test(`Should throw error 'expected a number followed by a suit, but got "invalid"' with invalid card`, () => { @@ -72,10 +53,27 @@ import { getCardValue } from "../implement/3-get-card-value.js"; // for valid case: // any of 2-9 (single digit number) with valid suit +test(`Should return 1-9 value when given 1-9 face card`, () => { + expect(getCardValue("2♠")).toEqual(2); + expect(getCardValue("7♥")).toEqual(7); + expect(getCardValue("9♦")).toEqual(9); + expect(getCardValue("5♠")).toEqual(5); +}); + // number 10 (double digit number) with valid suit +test(`Should return 10 value when given an 10 face card`, () => { + expect(getCardValue("2♠")).toEqual(2); +}); + // J/Q/K with valid suit (because they should return 10) +test(`Should return 10 when given a J, Q, K face card`, () => { + expect(getCardValue("J♠")).toEqual(10); + expect(getCardValue("Q♥")).toEqual(10); + expect(getCardValue("K♦")).toEqual(10); + expect(getCardValue("J♠")).toEqual(10); +}); + // A with valid suit (because it should specially return 11) -// Case 1: Ace (A) test(`Should return 11 when given an ace card`, () => { expect(getCardValue("A♠")).toEqual(11); }); From 5ad5c2a13e81447350a91ad4d83fa1d0713137a4 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 14:46:50 +0100 Subject: [PATCH 57/60] Working on adding in invalid case tests. --- .../3-get-card-value.test.js | 23 +++++++++++++------ 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index b45dc071a..adb79f02f 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -2,13 +2,6 @@ import { getCardValue } from "../implement/3-get-card-value.js"; // // Invalid Cards -// test(`Should throw error 'expected a number followed by a suit, but got "invalid"' with invalid card`, () => { -// expect(() => getCardValue("120♥")).toThrow( -// new Error('expected a number followed by a suit, but got "invalid"') -// ); -// expect(() => getCardValue("203♦")).toThrow( -// new Error('expected a number followed by a suit, but got "invalid"') -// ); // }); // // To learn how to test whether a function throws an error as expected in Jest, // // please refer to the Jest documentation: @@ -80,13 +73,29 @@ test(`Should return 11 when given an ace card`, () => { // for invalid case: // 1 (single digit number) with valid suit +test(`Should throw error "Incorrect face given" for face value 1`, () => { + expect(() => getCardValue("1♥")).toThrow(new Error("Incorrect face given")); +}); + // 11 (special double digit number) with valid suit +test(`Should throw error "Incorrect face given" for face value 11`, () => { + expect(() => getCardValue("11♥")).toThrow(new Error("Incorrect face given")); +}); + // any of 12-99 (double digit number) with valid suit + // any B-Z except J/Q/K with valid suit + // any invalid face with valid suit + // valid suit with valid face (e.g. "♠9") + // any invalid face with any invalid suit + // any of 2-9 (valid single digit number) with invalid suit + // number 10 (valid double digit number) with invalid suit + // J/Q/K with invalid suit + // A with invalid suit From 0ab03d7ec5a162a28eab95e079c2e89d33e4ca14 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 14:57:38 +0100 Subject: [PATCH 58/60] Adding more tests to Invalid options. --- .../3-get-card-value.test.js | 40 +++++++++++++++++-- 1 file changed, 36 insertions(+), 4 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index adb79f02f..eff434c97 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -7,10 +7,6 @@ import { getCardValue } from "../implement/3-get-card-value.js"; // // please refer to the Jest documentation: // // https://jestjs.io/docs/expect#tothrowerror -// test(`Should throw error "Incorrect suit given" when given wrong symbol"`, () => { -// expect(() => getCardValue("2☺")).toThrow(new Error("Incorrect suit given")); -// }); - // test(`Should throw error "Incorrect suit given" when given wrong letter"`, () => { // expect(() => getCardValue("2K")).toThrow(new Error("Incorrect suit given")); // }); @@ -83,16 +79,52 @@ test(`Should throw error "Incorrect face given" for face value 11`, () => { }); // any of 12-99 (double digit number) with valid suit +test(`Should throw error "Incorrect face given" for face value from 12-99`, () => { + expect(() => getCardValue("19♥")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("56♥")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("77♥")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("98♥")).toThrow(new Error("Incorrect face given")); +}); // any B-Z except J/Q/K with valid suit +test(`Should throw error "Incorrect face given" for face value from B-Z expect J/Q/K`, () => { + expect(() => getCardValue("B♥")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("G♥")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("L♥")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("O♥")).toThrow(new Error("Incorrect face given")); +}); // any invalid face with valid suit +test(`Should throw error "Incorrect face given" for any invalid face value with valid suit`, () => { + expect(() => getCardValue("1♥")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("G♥")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("66♥")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("O♥")).toThrow(new Error("Incorrect face given")); +}); // valid suit with valid face (e.g. "♠9") +test(`Should throw error "Incorrect suit given" when suit and face are in wrong order, eg: ♠9`, () => { + expect(() => getCardValue("♠9")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("♦4")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("♠K")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("♥A")).toThrow(new Error("Incorrect suit given")); +}); // any invalid face with any invalid suit +test(`Should throw error "Incorrect suit given" when invalid suit and face are given`, () => { + expect(() => getCardValue("19J")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("14@")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("L$*")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("1B")).toThrow(new Error("Incorrect suit given")); +}); // any of 2-9 (valid single digit number) with invalid suit +test(`Should throw error "Incorrect suit given" when given wrong suit with correct face between 2-9"`, () => { + expect(() => getCardValue("2☺")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("4☺")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("6☺")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("9☺")).toThrow(new Error("Incorrect suit given")); +}); // number 10 (valid double digit number) with invalid suit From d32864fbce1843b574f25f347a74bd411910e564 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 15:00:02 +0100 Subject: [PATCH 59/60] Done adding in new tests, now cleaning up older ones. --- .../rewrite-tests-with-jest/3-get-card-value.test.js | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index eff434c97..2017f9398 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -127,7 +127,17 @@ test(`Should throw error "Incorrect suit given" when given wrong suit with corre }); // number 10 (valid double digit number) with invalid suit - +test(`Should throw error "Incorrect suit given" when given wrong suit with correct face 10"`, () => { + expect(() => getCardValue("10☺")).toThrow(new Error("Incorrect suit given")); +}); // J/Q/K with invalid suit +test(`Should throw error "Incorrect suit given" when given wrong suit with correct face royals J/Q/K"`, () => { + expect(() => getCardValue("J☺")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("Q☺")).toThrow(new Error("Incorrect suit given")); + expect(() => getCardValue("K☺")).toThrow(new Error("Incorrect suit given")); +}); // A with invalid suit +test(`Should throw error "Incorrect suit given" when given wrong suit with correct face Ace"`, () => { + expect(() => getCardValue("A☺")).toThrow(new Error("Incorrect suit given")); +}); From 951e3a0c79186f229af7fcdb050a32f3d1892f14 Mon Sep 17 00:00:00 2001 From: HM-127BTY Date: Mon, 19 Oct 2026 15:02:30 +0100 Subject: [PATCH 60/60] All done adding in new tests and cleaning up older ones with nwe layout. 20 tests in total now. --- .../3-get-card-value.test.js | 54 ++++++++----------- 1 file changed, 22 insertions(+), 32 deletions(-) diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js index 2017f9398..005380688 100644 --- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js +++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js @@ -7,38 +7,6 @@ import { getCardValue } from "../implement/3-get-card-value.js"; // // please refer to the Jest documentation: // // https://jestjs.io/docs/expect#tothrowerror -// test(`Should throw error "Incorrect suit given" when given wrong letter"`, () => { -// expect(() => getCardValue("2K")).toThrow(new Error("Incorrect suit given")); -// }); - -// test(`Should throw error "Incorrect face given" when given wrong 2 digit number"`, () => { -// expect(() => getCardValue("25♠")).toThrow(new Error("Incorrect face given")); -// }); - -// test(`Should throw error "Incorrect face given" when given negative number"`, () => { -// expect(() => getCardValue("-2♠")).toThrow(new Error("Incorrect face given")); -// }); - -// test(`Should throw error "Incorrect face given" when given a lower case Royal"`, () => { -// expect(() => getCardValue("k♠")).toThrow(new Error("Incorrect face given")); -// }); - -// test(`Should throw error "Incorrect face given" when given a lower case Ace"`, () => { -// expect(() => getCardValue("a♠")).toThrow(new Error("Incorrect face given")); -// }); - -// test(`Should throw error "Incorrect face given" when given a letter"`, () => { -// expect(() => getCardValue("I♠")).toThrow(new Error("Incorrect face given")); -// }); - -// test(`Should throw error "Incorrect face given" when given symbol"`, () => { -// expect(() => getCardValue("🐱♠")).toThrow(new Error("Incorrect face given")); -// }); - -// test(`Should throw error "Input needed" if no imput given`, () => { -// expect(() => getCardValue("")).toThrow(new Error("Input needed")); -// }); - // for valid case: // any of 2-9 (single digit number) with valid suit @@ -141,3 +109,25 @@ test(`Should throw error "Incorrect suit given" when given wrong suit with corre test(`Should throw error "Incorrect suit given" when given wrong suit with correct face Ace"`, () => { expect(() => getCardValue("A☺")).toThrow(new Error("Incorrect suit given")); }); + +test(`Should throw error "Incorrect suit given" when given wrong letter"`, () => { + expect(() => getCardValue("2K")).toThrow(new Error("Incorrect suit given")); +}); + +test(`Should throw error "Incorrect face given" when given negative number"`, () => { + expect(() => getCardValue("-2♠")).toThrow(new Error("Incorrect face given")); +}); + +test(`Should throw error "Incorrect face given" when given a lower case Royal"`, () => { + expect(() => getCardValue("j♠")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("q♠")).toThrow(new Error("Incorrect face given")); + expect(() => getCardValue("k♠")).toThrow(new Error("Incorrect face given")); +}); + +test(`Should throw error "Incorrect face given" when given a lower case Ace"`, () => { + expect(() => getCardValue("a♠")).toThrow(new Error("Incorrect face given")); +}); + +test(`Should throw error "Input needed" if no input given`, () => { + expect(() => getCardValue("")).toThrow(new Error("Input needed")); +});