From 3934b5d216d01ca8c31b0dac90b8cb4a67136128 Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Thu, 23 Oct 2025 10:16:32 +0100
Subject: [PATCH 01/11] Added Jest test files for angle type, proper fraction,
 and card value functions

---
 .../implement/1-get-angle-type.js             | 18 +++++++--
 .../implement/2-is-proper-fraction.js         | 20 ++++++++--
 .../implement/3-get-card-value.js             | 38 ++++++++++++++++++-
 .../1-get-angle-type.test.js                  | 12 ++++++
 .../2-is-proper-fraction.test.js              | 11 ++++++
 .../3-get-card-value.test.js                  | 24 ++++++++++++
 6 files changed, 116 insertions(+), 7 deletions(-)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
index ca1dfe7f2..7563aeb43 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
@@ -10,6 +10,16 @@
 function getAngleType(angle) {
   if (angle === 90) {
     return "Right angle";
+  } else if (angle < 90 && angle > 0) {
+    return "Acute angle";
+  } else if (angle > 90 && angle < 180) {
+    return "Obtuse angle";
+  } else if (angle === 180) {
+    return "Straight angle";
+  } else if (angle > 180 && angle < 360) {
+    return "Reflex angle";
+  } else {
+    return "Invalid angle";
   }
    // Run the tests, work out what Case 2 is testing, and implement the required code here.
    // Then keep going for the other cases, one at a time.
@@ -50,14 +60,16 @@ assertEquals(acute, "Acute angle");
 // When the angle is greater than 90 degrees and less than 180 degrees,
 // Then the function should return "Obtuse angle"
 const obtuse = getAngleType(120);
-// ====> write your test here, and then add a line to pass the test in the function above
+assertEquals(obtuse, "Obtuse angle");
 
 // Case 4: Identify Straight Angles:
 // When the angle is exactly 180 degrees,
 // Then the function should return "Straight angle"
-// ====> write your test here, and then add a line to pass the test in the function above
+const straight = getAngleType(180);
+assertEquals(straight, "Straight angle");
 
 // Case 5: Identify Reflex Angles:
 // When the angle is greater than 180 degrees and less than 360 degrees,
 // Then the function should return "Reflex angle"
-// ====> write your test here, and then add a line to pass the test in the function above
\ No newline at end of file
+const reflex = getAngleType(270);
+assertEquals(reflex, "Reflex angle");
\ No newline at end of file
diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
index a4739af77..429f4d2ee 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
@@ -8,8 +8,16 @@
 // write one test at a time, and make it pass, build your solution up methodically
 
 function isProperFraction(numerator, denominator) {
-  if (numerator < denominator) {
+  // Handle invalid denominators (e.g., divide by zero)
+  if (denominator === 0) {
+    return false;
+  }
+
+  // Compare absolute values for proper fraction check
+  if (Math.abs(numerator) < Math.abs(denominator)) {
     return true;
+  } else {
+    return false;
   }
 }
 
@@ -46,14 +54,20 @@ assertEquals(improperFraction, false);
 // target output: true
 // Explanation: The fraction -4/7 is a proper fraction because the absolute value of the numerator (4) is less than the denominator (7). The function should return true.
 const negativeFraction = isProperFraction(-4, 7);
-// ====> complete with your assertion
+assertEquals(negativeFraction, true);
 
 // Equal Numerator and Denominator check:
 // Input: numerator = 3, denominator = 3
 // target output: false
 // Explanation: The fraction 3/3 is not a proper fraction because the numerator is equal to the denominator. The function should return false.
 const equalFraction = isProperFraction(3, 3);
-// ====> complete with your assertion
+assertEquals(equalFraction, false);
 
 // Stretch:
 // What other scenarios could you test for?
+// Zero Numerator check:
+// Input: numerator = 0, denominator = 5
+// target output: true
+// Explanation: The fraction 0/5 is a proper fraction because the numerator (0) is less than the denominator (5). The function should return true.
+const zeroNumerator = isProperFraction(0, 5);
+assertEquals(zeroNumerator, true);
diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
index 266525d1b..d96eda1fa 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
@@ -8,9 +8,26 @@
 // write one test at a time, and make it pass, build your solution up methodically
 // just make one change at a time -- don't rush -- programmers are deep and careful thinkers
 function getCardValue(card) {
+  // Extract rank (everything except the last character, which is the suit)
+  const rank = card.slice(0, -1);
+
+  // Handle Ace
   if (rank === "A") {
     return 11;
   }
+
+  // Handle Face Cards
+  if (["K", "Q", "J", "10"].includes(rank)) {
+    return 10;
+  }
+
+  // Handle Number Cards (2–9)
+  if (!isNaN(rank) && Number(rank) >= 2 && Number(rank) <= 9) {
+    return Number(rank);
+  }
+
+  // Handle invalid inputs
+  throw new Error("Invalid card rank");
 }
 
 // The line below allows us to load the getCardValue function into tests in other files.
@@ -39,19 +56,38 @@ assertEquals(aceofSpades, 11);
 // When the function is called with such a card,
 // Then it should return the numeric value corresponding to the rank (e.g., "5" should return 5).
 const fiveofHearts = getCardValue("5♥");
-// ====> write your test here, and then add a line to pass the test in the function above
+assertEquals(fiveofHearts, 5);
 
 // Handle Face Cards (J, Q, K):
 // Given a card with a rank of "10," "J," "Q," or "K",
 // When the function is called with such a card,
 // Then it should return the value 10, as these cards are worth 10 points each in blackjack.
+const jackOfDiamonds = getCardValue("J♦");
+assertEquals(jackOfDiamonds, 10);
+
+const queenOfClubs = getCardValue("Q♣");
+assertEquals(queenOfClubs, 10);
+
+const kingOfSpades = getCardValue("K♠");
+assertEquals(kingOfSpades, 10);
+
+const tenOfHearts = getCardValue("10♥");
+assertEquals(tenOfHearts, 10);
+
 
 // Handle Ace (A):
 // Given a card with a rank of "A",
 // When the function is called with an Ace,
 // Then it should, by default, assume the Ace is worth 11 points, which is a common rule in blackjack.
+const aceofClubs = getCardValue("A♣");
+assertEquals(aceofClubs, 11);
 
 // Handle Invalid Cards:
 // Given a card with an invalid rank (neither a number nor a recognized face card),
 // When the function is called with such a card,
 // Then it should throw an error indicating "Invalid card rank."
+try {
+  getCardValue("X♣");
+} catch (error) {
+  assertEquals(error.message, "Invalid card rank");
+}
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
index 4a92a3e82..c51c50ec4 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
@@ -12,15 +12,27 @@ test("should identify right angle (90°)", () => {
 // Case 2: Identify Acute Angles:
 // When the angle is less than 90 degrees,
 // Then the function should return "Acute angle"
+test("should identify acute angle (<90°)", () => {
+  expect(getAngleType(45)).toEqual("Acute angle");
+});
 
 // Case 3: Identify Obtuse Angles:
 // When the angle is greater than 90 degrees and less than 180 degrees,
 // Then the function should return "Obtuse angle"
+test("should identify obtuse angle (>90° and <180°)", () => {
+  expect(getAngleType(120)).toEqual("Obtuse angle");
+});
 
 // Case 4: Identify Straight Angles:
 // When the angle is exactly 180 degrees,
 // Then the function should return "Straight angle"
+test("should identify straight angle (180°)", () => {
+  expect(getAngleType(180)).toEqual("Straight angle");
+});
 
 // Case 5: Identify Reflex Angles:
 // When the angle is greater than 180 degrees and less than 360 degrees,
 // Then the function should return "Reflex angle"
+test("should identify reflex angle (>180° and <360°)", () => {
+  expect(getAngleType(270)).toEqual("Reflex angle");
+});
\ No newline at end of file
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
index caf08d15b..9d77a8eef 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
@@ -7,7 +7,18 @@ test("should return true for a proper fraction", () => {
 });
 
 // Case 2: Identify Improper Fractions:
+test("should return false for an improper fraction (numerator > denominator)", () => {
+  expect(isProperFraction(5, 3)).toEqual(false);
+});
 
 // Case 3: Identify Negative Fractions:
+test("should correctly handle negative fractions", () => {
+  expect(isProperFraction(-1, 3)).toEqual(true);
+  expect(isProperFraction(1, -3)).toEqual(true);
+  expect(isProperFraction(-4, 3)).toEqual(false);
+});
 
 // Case 4: Identify Equal Numerator and Denominator:
+test("should return false when numerator and denominator are equal", () => {
+  expect(isProperFraction(3, 3)).toEqual(false);
+});
\ No newline at end of file
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
index 04418ff72..b91171a8b 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
@@ -8,6 +8,30 @@ test("should return 11 for Ace of Spades", () => {
 });
 
 // Case 2: Handle Number Cards (2-10):
+test("should return correct value for number cards", () => {
+  expect(getCardValue("2♥")).toEqual(2);
+  expect(getCardValue("5♦")).toEqual(5);
+  expect(getCardValue("9♣")).toEqual(9);
+  expect(getCardValue("10♠")).toEqual(10);
+});
+
 // Case 3: Handle Face Cards (J, Q, K):
+test("should return 10 for face cards (J, Q, K)", () => {
+  expect(getCardValue("J♦")).toEqual(10);
+  expect(getCardValue("Q♥")).toEqual(10);
+  expect(getCardValue("K♣")).toEqual(10);
+});
+
 // Case 4: Handle Ace (A):
+test("should return 11 for Ace of any suit", () => {
+  expect(getCardValue("A♣")).toEqual(11);
+  expect(getCardValue("A♦")).toEqual(11);
+  expect(getCardValue("A♥")).toEqual(11);
+});
+
 // Case 5: Handle Invalid Cards:
+test("should throw an error for invalid card ranks", () => {
+  expect(() => getCardValue("X♣")).toThrow("Invalid card rank");
+  expect(() => getCardValue("1♠")).toThrow("Invalid card rank");
+  expect(() => getCardValue("Z♦")).toThrow("Invalid card rank");
+});
\ No newline at end of file

From ced98d63d38c2cea94d00b45b30c6b0991a9db8b Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Wed, 29 Oct 2025 08:44:58 +0000
Subject: [PATCH 02/11] Made small  test with jest changes

---
 .../implement/1-get-angle-type.js             |  2 +-
 .../implement/2-is-proper-fraction.js         | 12 +----
 .../implement/3-get-card-value.js             | 45 +++++++------------
 .../2-is-proper-fraction.test.js              | 14 +++---
 .../3-get-card-value.test.js                  | 28 +++++-------
 5 files changed, 37 insertions(+), 64 deletions(-)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
index 7563aeb43..56c6a997d 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
@@ -10,7 +10,7 @@
 function getAngleType(angle) {
   if (angle === 90) {
     return "Right angle";
-  } else if (angle < 90 && angle > 0) {
+  } else if (angle < 90) {
     return "Acute angle";
   } else if (angle > 90 && angle < 180) {
     return "Obtuse angle";
diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
index 429f4d2ee..b2b6a6b82 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
@@ -8,17 +8,7 @@
 // write one test at a time, and make it pass, build your solution up methodically
 
 function isProperFraction(numerator, denominator) {
-  // Handle invalid denominators (e.g., divide by zero)
-  if (denominator === 0) {
-    return false;
-  }
-
-  // Compare absolute values for proper fraction check
-  if (Math.abs(numerator) < Math.abs(denominator)) {
-    return true;
-  } else {
-    return false;
-  }
+  return Math.abs(numerator) < Math.abs(denominator);
 }
 
 // The line below allows us to load the isProperFraction function into tests in other files.
diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
index d96eda1fa..6a4f4530c 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
@@ -8,26 +8,20 @@
 // write one test at a time, and make it pass, build your solution up methodically
 // just make one change at a time -- don't rush -- programmers are deep and careful thinkers
 function getCardValue(card) {
-  // Extract rank (everything except the last character, which is the suit)
-  const rank = card.slice(0, -1);
+  let rank = card.slice(0, card.length - 1);
 
-  // Handle Ace
   if (rank === "A") {
     return 11;
-  }
 
-  // Handle Face Cards
-  if (["K", "Q", "J", "10"].includes(rank)) {
+  }  else if ((parseInt(rank) >= 2 && parseInt(rank)) && parseInt(rank) < 11){
+    return parseInt(rank)
+  }
+  else if( rank === "J" || rank === "Q" || rank === "K") {
     return 10;
   }
-
-  // Handle Number Cards (2–9)
-  if (!isNaN(rank) && Number(rank) >= 2 && Number(rank) <= 9) {
-    return Number(rank);
+  else{
+    throw  new Error("Invalid card rank.")
   }
-
-  // Handle invalid inputs
-  throw new Error("Invalid card rank");
 }
 
 // The line below allows us to load the getCardValue function into tests in other files.
@@ -62,32 +56,27 @@ assertEquals(fiveofHearts, 5);
 // Given a card with a rank of "10," "J," "Q," or "K",
 // When the function is called with such a card,
 // Then it should return the value 10, as these cards are worth 10 points each in blackjack.
-const jackOfDiamonds = getCardValue("J♦");
-assertEquals(jackOfDiamonds, 10);
-
-const queenOfClubs = getCardValue("Q♣");
-assertEquals(queenOfClubs, 10);
-
-const kingOfSpades = getCardValue("K♠");
-assertEquals(kingOfSpades, 10);
-
-const tenOfHearts = getCardValue("10♥");
-assertEquals(tenOfHearts, 10);
+const cardOfJ = getCardValue("J♥");
+assertEquals(cardOfJ, 10);
+const cardOfQ = getCardValue("Q♠");
+assertEquals(cardOfQ, 10);
+const cardOfK = getCardValue("K♠");
+assertEquals(cardOfK, 10);
 
 
 // Handle Ace (A):
 // Given a card with a rank of "A",
 // When the function is called with an Ace,
 // Then it should, by default, assume the Ace is worth 11 points, which is a common rule in blackjack.
-const aceofClubs = getCardValue("A♣");
-assertEquals(aceofClubs, 11);
+const aceOfHeart = getCardValue("A♥");
+assertEquals(aceOfHeart, 11);
 
 // Handle Invalid Cards:
 // Given a card with an invalid rank (neither a number nor a recognized face card),
 // When the function is called with such a card,
 // Then it should throw an error indicating "Invalid card rank."
 try {
-  getCardValue("X♣");
+  assertEquals(getCardValue("X♥"), "Invalid card rank");
 } catch (error) {
-  assertEquals(error.message, "Invalid card rank");
+  console.log(error.message);
 }
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
index 9d77a8eef..53e20b336 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
@@ -4,21 +4,19 @@ const isProperFraction = require("../implement/2-is-proper-fraction");
 
 test("should return true for a proper fraction", () => {
   expect(isProperFraction(2, 3)).toEqual(true);
-});
+}); 
 
 // Case 2: Identify Improper Fractions:
-test("should return false for an improper fraction (numerator > denominator)", () => {
-  expect(isProperFraction(5, 3)).toEqual(false);
+test("should return false for improper fraction", () => {
+  expect(isProperFraction(5, 2)).toEqual(false);
 });
 
 // Case 3: Identify Negative Fractions:
-test("should correctly handle negative fractions", () => {
-  expect(isProperFraction(-1, 3)).toEqual(true);
-  expect(isProperFraction(1, -3)).toEqual(true);
-  expect(isProperFraction(-4, 3)).toEqual(false);
+test("should return true for negative fraction", () => {
+  expect(isProperFraction(-4, 7)).toEqual(true);
 });
 
 // Case 4: Identify Equal Numerator and Denominator:
-test("should return false when numerator and denominator are equal", () => {
+test("should return false for Equal Numerator fraction", () => {
   expect(isProperFraction(3, 3)).toEqual(false);
 });
\ No newline at end of file
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
index b91171a8b..e79834405 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
@@ -9,29 +9,25 @@ test("should return 11 for Ace of Spades", () => {
 
 // Case 2: Handle Number Cards (2-10):
 test("should return correct value for number cards", () => {
-  expect(getCardValue("2♥")).toEqual(2);
-  expect(getCardValue("5♦")).toEqual(5);
-  expect(getCardValue("9♣")).toEqual(9);
-  expect(getCardValue("10♠")).toEqual(10);
+  const fiveheart = getCardValue("5♥");
+  expect(fiveheart).toEqual(5);
 });
 
 // Case 3: Handle Face Cards (J, Q, K):
-test("should return 10 for face cards (J, Q, K)", () => {
-  expect(getCardValue("J♦")).toEqual(10);
-  expect(getCardValue("Q♥")).toEqual(10);
-  expect(getCardValue("K♣")).toEqual(10);
+test("Case 3: Handle Face Cards (J, Q, K)", () => {
+  const cardOfJ = getCardValue("J♥");
+  expect(cardOfJ).toEqual(10);
 });
 
 // Case 4: Handle Ace (A):
-test("should return 11 for Ace of any suit", () => {
-  expect(getCardValue("A♣")).toEqual(11);
-  expect(getCardValue("A♦")).toEqual(11);
-  expect(getCardValue("A♥")).toEqual(11);
+test("Case 4: Handle Face Cards (J, Q, K)", () => {
+  const aceOfHeart = getCardValue("A♥");
+  expect(aceOfHeart).toEqual(11);
 });
 
 // Case 5: Handle Invalid Cards:
-test("should throw an error for invalid card ranks", () => {
-  expect(() => getCardValue("X♣")).toThrow("Invalid card rank");
-  expect(() => getCardValue("1♠")).toThrow("Invalid card rank");
-  expect(() => getCardValue("Z♦")).toThrow("Invalid card rank");
+test("Case 5: Handle Invalid Cards", () => {
+  expect(() => {
+    getCardValue("21♠");
+  }).toThrow("Invalid card rank");
 });
\ No newline at end of file

From be08b79b566e9ff30dc9876747107b8d384548ab Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Wed, 29 Oct 2025 15:53:19 +0000
Subject: [PATCH 03/11] Fixed errors

---
 .../implement/3-get-card-value.js               | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
index 6a4f4530c..9932f2422 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
@@ -8,20 +8,23 @@
 // write one test at a time, and make it pass, build your solution up methodically
 // just make one change at a time -- don't rush -- programmers are deep and careful thinkers
 function getCardValue(card) {
-  let rank = card.slice(0, card.length - 1);
+  let rank = card.slice(0, -1); 
 
   if (rank === "A") {
     return 11;
 
-  }  else if ((parseInt(rank) >= 2 && parseInt(rank)) && parseInt(rank) < 11){
-    return parseInt(rank)
-  }
-  else if( rank === "J" || rank === "Q" || rank === "K") {
+  }  
+  
+   if (["K", "Q", "J"].includes(rank)) {
     return 10;
   }
-  else{
+
+  const num = parseInt(rank, 10);
+  if (num >= 2 && num <= 10) {
+    return num;
+  } 
     throw  new Error("Invalid card rank.")
-  }
+  
 }
 
 // The line below allows us to load the getCardValue function into tests in other files.

From 645049648b2faaff4da1707443d0545d3fdd2c43 Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Sat, 1 Nov 2025 15:31:59 +0000
Subject: [PATCH 04/11] Fixed errors

---
 .../rewrite-tests-with-jest/3-get-card-value.test.js          | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
index e79834405..723075bd7 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
@@ -9,8 +9,8 @@ test("should return 11 for Ace of Spades", () => {
 
 // Case 2: Handle Number Cards (2-10):
 test("should return correct value for number cards", () => {
-  const fiveheart = getCardValue("5♥");
-  expect(fiveheart).toEqual(5);
+  const fiveHeart = getCardValue("5♥");
+  expect(fiveHeart).toEqual(5);
 });
 
 // Case 3: Handle Face Cards (J, Q, K):

From c48508e932b647eaa8cb1958a91f53258c05d15d Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Tue, 4 Nov 2025 09:34:00 +0000
Subject: [PATCH 05/11] Fixed errors

---
 .../implement/2-is-proper-fraction.js          | 14 ++++++++++++++
 .../implement/3-get-card-value.js              |  2 ++
 .../3-get-card-value.test.js                   | 18 ++++++++++++++++--
 3 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
index b2b6a6b82..d1333c3d5 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
@@ -61,3 +61,17 @@ assertEquals(equalFraction, false);
 // Explanation: The fraction 0/5 is a proper fraction because the numerator (0) is less than the denominator (5). The function should return true.
 const zeroNumerator = isProperFraction(0, 5);
 assertEquals(zeroNumerator, true);
+
+// Negative Numerator check:
+// Input: numerator = -3, denominator = 4
+// target output: true
+// Explanation: The fraction -3/4 is a proper fraction because the absolute value of numerator (3) is less than denominator (4)
+const negativeNumerator = isProperFraction(-3, 4);
+assertEquals(negativeNumerator, true);
+
+// Equal Values check:
+// Input: numerator = 7, denominator = 7
+// target output: false
+// Explanation: The fraction 7/7 is NOT a proper fraction because the numerator equals the denominator (not less than)
+const equalValues = isProperFraction(7, 7);
+assertEquals(equalValues, false);
\ No newline at end of file
diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
index 9932f2422..efe77d0d4 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
@@ -65,6 +65,8 @@ const cardOfQ = getCardValue("Q♠");
 assertEquals(cardOfQ, 10);
 const cardOfK = getCardValue("K♠");
 assertEquals(cardOfK, 10);
+const cardOf10 = getCardValue("10♣");
+assertEquals(cardOf10, 10);
 
 
 // Handle Ace (A):
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
index 723075bd7..d5a5b6bf2 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
@@ -14,13 +14,21 @@ test("should return correct value for number cards", () => {
 });
 
 // Case 3: Handle Face Cards (J, Q, K):
-test("Case 3: Handle Face Cards (J, Q, K)", () => {
+test("Case 3: Handle Face Card (J)", () => {
   const cardOfJ = getCardValue("J♥");
   expect(cardOfJ).toEqual(10);
 });
+test("Case 3: Handle Face Cards (Q)", () => {
+  const cardOfQ = getCardValue("Q♠");
+  expect(cardOfQ).toEqual(10);
+});
+test("Case 3: Handle Face Cards (K)", () => {
+  const cardOfK = getCardValue("K♠");
+  expect(cardOfK).toEqual(10);
+});
 
 // Case 4: Handle Ace (A):
-test("Case 4: Handle Face Cards (J, Q, K)", () => {
+test("Case 4: Handle Face Cards (A)", () => {
   const aceOfHeart = getCardValue("A♥");
   expect(aceOfHeart).toEqual(11);
 });
@@ -30,4 +38,10 @@ test("Case 5: Handle Invalid Cards", () => {
   expect(() => {
     getCardValue("21♠");
   }).toThrow("Invalid card rank");
+});
+
+test("Case 6: Handle card with invalid rank", () => {
+  expect(() => {
+    getCardValue("ZC");
+  }).toThrow("Invalid card rank");
 });
\ No newline at end of file

From a36eb228b8dbe466be5ac8eb90b46e8999429d9b Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Wed, 5 Nov 2025 01:22:55 +0000
Subject: [PATCH 06/11] Added test cases with decimal

---
 .../2-is-proper-fraction.test.js                      | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
index 53e20b336..e892eeeb2 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
@@ -19,4 +19,13 @@ test("should return true for negative fraction", () => {
 // Case 4: Identify Equal Numerator and Denominator:
 test("should return false for Equal Numerator fraction", () => {
   expect(isProperFraction(3, 3)).toEqual(false);
-});
\ No newline at end of file
+});
+
+// Improper fractions as decimals
+test('1.5 should not be proper (3/2)', () => {
+  expect(isProperFraction(1.5)).toBe(false);
+});
+
+test('2.25 should not be proper (9/4)', () => {
+  expect(isProperFraction(2.25)).toBe(false);
+});

From d5c9c238d36f3ff22bd86773283a59f33ecf3d98 Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Wed, 5 Nov 2025 01:49:51 +0000
Subject: [PATCH 07/11] Removed a typo

---
 .../implement/1-get-angle-type.js                            | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
index 56c6a997d..44f21708e 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
@@ -18,9 +18,8 @@ function getAngleType(angle) {
     return "Straight angle";
   } else if (angle > 180 && angle < 360) {
     return "Reflex angle";
-  } else {
-    return "Invalid angle";
-  }
+  } 
+  
    // Run the tests, work out what Case 2 is testing, and implement the required code here.
    // Then keep going for the other cases, one at a time.
 }

From 9f6270183ef53cbee0f14d2ccf17e90a7e581871 Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Wed, 5 Nov 2025 15:41:42 +0000
Subject: [PATCH 08/11] Fix: handle invalid angles below 0 or above 360 in
 getAngleType

---
 .../implement/1-get-angle-type.js                    | 12 +++++++++---
 .../rewrite-tests-with-jest/1-get-angle-type.test.js |  7 ++++++-
 2 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
index 44f21708e..d9e9fc4ad 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
@@ -8,7 +8,9 @@
 // Then, write the next test! :) Go through this process until all the cases are implemented
 
 function getAngleType(angle) {
-  if (angle === 90) {
+  if (angle < 0 || angle >= 360) {
+    return "Invalid angle";
+  } else if (angle === 90) {
     return "Right angle";
   } else if (angle < 90) {
     return "Acute angle";
@@ -18,11 +20,15 @@ function getAngleType(angle) {
     return "Straight angle";
   } else if (angle > 180 && angle < 360) {
     return "Reflex angle";
-  } 
+  } else {
+    return "Invalid angle";
+  }
+}
+
   
    // Run the tests, work out what Case 2 is testing, and implement the required code here.
    // Then keep going for the other cases, one at a time.
-}
+
 
 // The line below allows us to load the getAngleType function into tests in other files.
 // This will be useful in the "rewrite tests with jest" step.
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
index c51c50ec4..ee2c83c8d 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
@@ -35,4 +35,9 @@ test("should identify straight angle (180°)", () => {
 // Then the function should return "Reflex angle"
 test("should identify reflex angle (>180° and <360°)", () => {
   expect(getAngleType(270)).toEqual("Reflex angle");
-});
\ No newline at end of file
+});
+
+// Additional tests for invalid angles
+
+expect(getAngleType(-10)).toBe("Invalid angle");
+expect(getAngleType(400)).toBe("Invalid angle");

From 09965f1de9491e5e683e672a0e9db23110424dd2 Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Wed, 5 Nov 2025 16:47:07 +0000
Subject: [PATCH 09/11] Refactored separate invalid angle tests

---
 .../rewrite-tests-with-jest/1-get-angle-type.test.js  | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
index ee2c83c8d..4720d756b 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
@@ -41,3 +41,14 @@ test("should identify reflex angle (>180° and <360°)", () => {
 
 expect(getAngleType(-10)).toBe("Invalid angle");
 expect(getAngleType(400)).toBe("Invalid angle");
+
+
+// Test for negative angle
+test("should return 'Invalid angle' for negative values", () => {
+  expect(getAngleType(-10)).toBe("Invalid angle");
+});
+
+// Test for angle >= 360
+test("should return 'Invalid angle' for values >= 360", () => {
+  expect(getAngleType(400)).toBe("Invalid angle");
+});
\ No newline at end of file

From a25cc1ba094aa48826877a4569fe53c59fdd9518 Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Wed, 5 Nov 2025 17:00:35 +0000
Subject: [PATCH 10/11] Fixed

---
 .../1-get-angle-type.test.js                   | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
index 4720d756b..06cbae6ec 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
@@ -36,19 +36,9 @@ test("should identify straight angle (180°)", () => {
 test("should identify reflex angle (>180° and <360°)", () => {
   expect(getAngleType(270)).toEqual("Reflex angle");
 });
-
-// Additional tests for invalid angles
+// Additional test: Identify Invalid Angles:
+// When the angle is less than 0 degrees or greater than or equal to 360 degrees,
+// Then the function should return "Invalid angle"
 
 expect(getAngleType(-10)).toBe("Invalid angle");
-expect(getAngleType(400)).toBe("Invalid angle");
-
-
-// Test for negative angle
-test("should return 'Invalid angle' for negative values", () => {
-  expect(getAngleType(-10)).toBe("Invalid angle");
-});
-
-// Test for angle >= 360
-test("should return 'Invalid angle' for values >= 360", () => {
-  expect(getAngleType(400)).toBe("Invalid angle");
-});
\ No newline at end of file
+expect(getAngleType(400)).toBe("Invalid angle");
\ No newline at end of file

From a7b091eb44f9b724f53b8b164600259a6ee1430f Mon Sep 17 00:00:00 2001
From: Khor Biel <khorkoak@gmail.com>
Date: Wed, 5 Nov 2025 20:11:00 +0000
Subject: [PATCH 11/11] Fixed errors

---
 .../rewrite-tests-with-jest/1-get-angle-type.test.js   | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
index 06cbae6ec..f816cab8a 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
@@ -36,9 +36,11 @@ test("should identify straight angle (180°)", () => {
 test("should identify reflex angle (>180° and <360°)", () => {
   expect(getAngleType(270)).toEqual("Reflex angle");
 });
-// Additional test: Identify Invalid Angles:
+
+// Additional test: Identify Invalid Angle:
 // When the angle is less than 0 degrees or greater than or equal to 360 degrees,
 // Then the function should return "Invalid angle"
-
-expect(getAngleType(-10)).toBe("Invalid angle");
-expect(getAngleType(400)).toBe("Invalid angle");
\ No newline at end of file
+test("should identify invalid angle (<0° or >=360°)", () => {
+  expect(getAngleType(-10)).toEqual("Invalid angle");
+  expect(getAngleType(360)).toEqual("Invalid angle");
+});
\ No newline at end of file