From ba7c34810b3e6f7d9b1325ccfecdfc61236f76c8 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 00:44:36 +0100
Subject: [PATCH 01/32] update: Implement angle type identification in
 getAngleType function

---
 Sprint-3/1-key-implement/1-get-angle-type.js | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/Sprint-3/1-key-implement/1-get-angle-type.js b/Sprint-3/1-key-implement/1-get-angle-type.js
index 08d1f0cba..49185fded 100644
--- a/Sprint-3/1-key-implement/1-get-angle-type.js
+++ b/Sprint-3/1-key-implement/1-get-angle-type.js
@@ -8,8 +8,16 @@
 // Then, write the next test! :) Go through this process until all the cases are implemented
 
 function getAngleType(angle) {
-   if (angle === 90) return "Right angle";
-   // read to the end, complete line 36, then pass your test here
+  if (angle === 90) return "Right angle";
+  // read to the end, complete line 36, then pass your test here
+  // if the angle is less than 90, return "Acute angle"
+  if (angle < 90) return "Acute angle";
+  // if the angle is greater than 90 and less than 180, return "Obtuse angle"
+  if (angle > 90 && angle < 180) return "Obtuse angle";
+  //  if the angle is exactly 180, return "Straight angle"
+  if (angle === 180) return "Straight angle";
+  // if the angle is greater than 180 and less than 360, return "Reflex angle"
+  if (angle > 180 && angle < 360) return "Reflex angle";
 }
 
 // we're going to use this helper function to make our assertions easier to read
@@ -43,14 +51,19 @@ 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);
+assertEquals(obtuse, "Obtuse angle");
 // ====> write your test here, and then add a line to pass the test in the function above
 
 // 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 straightAngle = getAngleType(180);
+assertEquals(straightAngle, "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
+// ====> write your test here, and then add a line to pass the test in the function above
+const reflex = getAngleType(270);
+assertEquals(reflex, "Reflex angle");

From e6d6e766bc49146536b717eba1e4bae3130555a0 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 00:46:09 +0100
Subject: [PATCH 02/32] UPdate: fix isProperFraction function to handle
 negative numbers and add tests for zero numerator and denominator

---
 .../1-key-implement/2-is-proper-fraction.js   | 20 +++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/Sprint-3/1-key-implement/2-is-proper-fraction.js b/Sprint-3/1-key-implement/2-is-proper-fraction.js
index 91583e941..25112cb4a 100644
--- a/Sprint-3/1-key-implement/2-is-proper-fraction.js
+++ b/Sprint-3/1-key-implement/2-is-proper-fraction.js
@@ -8,7 +8,8 @@
 // write one test at a time, and make it pass, build your solution up methodically
 
 function isProperFraction(numerator, denominator) {
-    if (numerator < denominator) return true;
+  // if (numerator < denominator) return true; it will not work for negative numbers
+  return Math.abs(numerator) < Math.abs(denominator);
 }
 
 // here's our helper again
@@ -41,6 +42,7 @@ assertEquals(improperFraction, false);
 // 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
@@ -48,6 +50,20 @@ const negativeFraction = isProperFraction(-4, 7);
 // 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);
+
+// Zero Denominator check:
+// Input: numerator = 4, denominator = 0
+// target output: false
+// Explanation: A fraction with a zero denominator is undefined. The function should return false to indicate it's not a valid proper fraction.
+const zeroDenominator = isProperFraction(4, 0);
+assertEquals(zeroDenominator, false);

From cea35124a866e7b2929d573a6a105562a5b23371 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 00:47:06 +0100
Subject: [PATCH 03/32] Update: fix getCardValue function to handle face cards,
 numeric ranks, and invalid inputs with corresponding tests

---
 Sprint-3/1-key-implement/3-get-card-value.js | 39 +++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/Sprint-3/1-key-implement/3-get-card-value.js b/Sprint-3/1-key-implement/3-get-card-value.js
index aa1cc9f90..7bebb6e1a 100644
--- a/Sprint-3/1-key-implement/3-get-card-value.js
+++ b/Sprint-3/1-key-implement/3-get-card-value.js
@@ -8,7 +8,22 @@
 // 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) {
-    if (rank === "A") return 11;
+  const rank = card.slice(0, -1); // Extract the rank from the card string
+
+  if (rank === "A") return 11;
+
+  // Face cards and 10 are worth 10 points
+  if (["10", "J", "Q", "K"].includes(rank)) {
+    return 10;
+  }
+  // Convert rank to number and check if it's a valid number card
+  const numericRank = Number(rank);
+  if (!isNaN(numericRank)) {
+    return numericRank;
+  }
+  // If rank is not valid, throw an error
+  throw new Error("Invalid card rank.");
+  // Note: The function assumes the input is always a valid card string
 }
 
 // You need to write assertions for your function to check it works in different cases
@@ -34,18 +49,40 @@ assertEquals(aceofSpades, 11);
 // 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); // 5 of Hearts should return 5 but still we need to implement this in the function
 
 // 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 tenOfDiamonds = getCardValue("10♦");
+assertEquals(tenOfDiamonds, 10); // 10 of Diamonds should return 10
+const jackOfClubs = getCardValue("J♣");
+assertEquals(jackOfClubs, 10); // Jack of Clubs should return 10
+const queenOfSpades = getCardValue("Q♠");
+assertEquals(queenOfSpades, 10); // Queen of Spades should return 10
+const kingOfHearts = getCardValue("K♥");
+assertEquals(kingOfHearts, 10); // King of Hearts should return 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 aceOfDiamonds = getCardValue("A♦");
+assertEquals(aceOfDiamonds, 11); // Ace of Diamonds should return 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."
+// Invalid card test (should throw error)
+try {
+  getCardValue("Z♠");
+  console.assert(false, "Expected error for invalid rank");
+} catch (e) {
+  console.assert(
+    e.message === "Invalid card rank.",
+    `Unexpected error message: ${e.message}`
+  );
+}

From d375cee33eaa4869d57fd040176763dbfe51ae3f Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 00:53:40 +0100
Subject: [PATCH 04/32] Update: fix  getAngleType function to improve
 readability and ensure proper angle classification with consolelog

---
 .../2-mandatory-rewrite/1-get-angle-type.js   | 31 ++++++++++++++-----
 1 file changed, 23 insertions(+), 8 deletions(-)

diff --git a/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js b/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js
index d61254bd7..0e5e3f435 100644
--- a/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js
+++ b/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js
@@ -1,18 +1,33 @@
 function getAngleType(angle) {
-  if (angle === 90) return "Right angle";
   // replace with your completed function from key-implement
+  // Step 1: Check for a right angle (exactly 90 degrees)
+  if (angle === 90) return "Right angle";
 
-}
-
-
-
-
+  // Step 2: Check for a straight angle (exactly 180 degrees)
+  if (angle === 180) return "Straight angle";
 
+  // Step 3: Check for an acute angle (between 0 and 90)
+  if (angle > 0 && angle < 90) return "Acute Angle";
 
+  // Step 4: Check for an obtuse angle (between 90 and 180)
+  if (angle > 90 && angle < 180) return "Obtuse angle";
+  // Step 5: Check for a reflex angle (between 180 and 360)
+  if (angle > 180 && angle < 360) return "Reflex angle";
 
+  // Step 6: Handle invalid or unsupported input
+  return "Invalid angle";
+}
 
 // Don't get bogged down in this detail
 // Jest uses CommonJS module syntax by default as it's quite old
-// We will upgrade our approach to ES6 modules in the next course module, so for now 
+// We will upgrade our approach to ES6 modules in the next course module, so for now
 // we have just written the CommonJS module.exports syntax for you
-module.exports = getAngleType;
\ No newline at end of file
+module.exports = getAngleType;
+
+console.log(getAngleType(90)); // "Right angle"
+console.log(getAngleType(180)); // "Straight angle"
+console.log(getAngleType(45)); // "Acute angle"
+console.log(getAngleType(120)); // "Obtuse angle"
+console.log(getAngleType(0)); // "Invalid angle"
+console.log(getAngleType(200)); // "Invalid angle"
+console.log(getAngleType(90.5)); // "Invalid angle"

From f66a15ad5b41d42bd7003e15fb5e91171b769afb Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 00:55:06 +0100
Subject: [PATCH 05/32] Update: fix and test descriptions for angle type
 identification for clarity and readability

---
 .../1-get-angle-type.test.js                  | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/Sprint-3/2-mandatory-rewrite/1-get-angle-type.test.js b/Sprint-3/2-mandatory-rewrite/1-get-angle-type.test.js
index b62827b7c..2d41f61ea 100644
--- a/Sprint-3/2-mandatory-rewrite/1-get-angle-type.test.js
+++ b/Sprint-3/2-mandatory-rewrite/1-get-angle-type.test.js
@@ -1,24 +1,31 @@
-const getAngleType = require("./1-get-angle-type");
+const getAngleType = require("./1-get-angle-type"); // Import the function to be tested
 
 test("should identify right angle (90°)", () => {
   expect(getAngleType(90)).toEqual("Right angle");
 });
 
-// REPLACE the comments with the tests
-// make your test descriptions as clear and readable as possible
-
 // Case 2: Identify Acute Angles:
 // When the angle is less than 90 degrees,
 // Then the function should return "Acute angle"
 
+test("should identify Acute Angles (< 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 && <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 Straight Angle (> 180 &&  < 360)", () => {
+  expect(getAngleType(278)).toEqual("Reflex angle");
+});

From e67b16269e7a99a287c154788a2baa7c5eed4f08 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 00:55:30 +0100
Subject: [PATCH 06/32] Update: comment out example console logs in
 getAngleType function for cleaner code

---
 Sprint-3/2-mandatory-rewrite/1-get-angle-type.js | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js b/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js
index 0e5e3f435..d2e6b06e2 100644
--- a/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js
+++ b/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js
@@ -24,10 +24,10 @@ function getAngleType(angle) {
 // we have just written the CommonJS module.exports syntax for you
 module.exports = getAngleType;
 
-console.log(getAngleType(90)); // "Right angle"
-console.log(getAngleType(180)); // "Straight angle"
-console.log(getAngleType(45)); // "Acute angle"
-console.log(getAngleType(120)); // "Obtuse angle"
-console.log(getAngleType(0)); // "Invalid angle"
-console.log(getAngleType(200)); // "Invalid angle"
-console.log(getAngleType(90.5)); // "Invalid angle"
+// console.log(getAngleType(90)); // "Right angle"
+// console.log(getAngleType(180)); // "Straight angle"
+// console.log(getAngleType(45)); // "Acute angle"
+// console.log(getAngleType(120)); // "Obtuse angle"
+// console.log(getAngleType(0)); // "Invalid angle"
+// console.log(getAngleType(200)); // "Invalid angle"
+// console.log(getAngleType(90.5)); // "Invalid angle"

From 0a7cda4234d2fb0be1594c08b6116592c90b62e8 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 00:56:33 +0100
Subject: [PATCH 07/32] Update: test isProperFraction function to include
 comprehensive checks for numerator and denominator, ensuring proper fraction
 validation

---
 .../2-is-proper-fraction.js                   | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.js b/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.js
index 9836fe398..90315e03c 100644
--- a/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.js
+++ b/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.js
@@ -1,6 +1,19 @@
 function isProperFraction(numerator, denominator) {
-    if (numerator < denominator) return true;
-    // add your completed function from key-implement here
+  if (denominator === 0) return false; // Avoid division by zero
+  if (numerator < 0 || denominator < 0) return false; // Proper fractions are positive
+  if (numerator < denominator) return true; // Proper if numerator < denominator
+  return false; // Otherwise, it's improper
 }
 
-module.exports = isProperFraction;
\ No newline at end of file
+module.exports = isProperFraction;
+// Test cases for the isProperFraction function
+console.log(isProperFraction(1, 2)); // true
+console.log(isProperFraction(3, 4)); // true
+console.log(isProperFraction(5, 5)); // false
+console.log(isProperFraction(7, 6)); // false
+console.log(isProperFraction(0, 1)); // true
+console.log(isProperFraction(1, 0)); // false (denominator is zero)
+console.log(isProperFraction(-1, 2)); // false (negative numerator)
+console.log(isProperFraction(1, -2)); // false (negative denominator)
+console.log(isProperFraction(-1, -2)); // false (both negative)
+console.log(isProperFraction(2, 3)); // true

From 87fc686cad6f75ccdc833dc3c2f752c550394866 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 00:58:28 +0100
Subject: [PATCH 08/32] Update: test isProperFraction function is correct and
 reintroduce usage examples

---
 .../2-is-proper-fraction.test.js              | 30 ++++++++++++++-----
 1 file changed, 23 insertions(+), 7 deletions(-)

diff --git a/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.test.js b/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.test.js
index ff1cc8173..022627492 100644
--- a/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.test.js
+++ b/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.test.js
@@ -1,11 +1,27 @@
-const isProperFraction = require("./2-is-proper-fraction");
+function isProperFraction(numerator, denominator) {
+  // Case 1: Check for zero denominator (undefined)
+  if (denominator === 0) return false;
 
-test("should return true for a proper fraction", () => {
-  expect(isProperFraction(2, 3)).toEqual(true);
-});
+  // Case 2: Check for negative values (numerator or denominator)
+  if (numerator < 0 || denominator < 0) return false;
 
-// Case 2: Identify Improper Fractions:
+  // Case 3: Check for equal numerator and denominator
+  if (numerator === denominator) return false;
 
-// Case 3: Identify Negative Fractions:
+  // Case 4: Check for proper fraction (numerator < denominator)
+  return numerator < denominator;
+}
+module.exports = isProperFraction;
+// usage examples
+console.log(isProperFraction(2, 3)); // true
+console.log(isProperFraction(5, 3)); // false
+console.log(isProperFraction(3, 3)); // false
+console.log(isProperFraction(-2, 3)); // false
+console.log(isProperFraction(2, -3)); // false
+console.log(isProperFraction(0, 5)); // true (0 < 5)
+console.log(isProperFraction(2, 2)); // false
 
-// Case 4: Identify Equal Numerator and Denominator:
+// Test cases for the isProperFraction function
+// test("should return true for a proper fraction", () => {
+//   expect(isProperFraction(2, 3)).toEqual(true);
+// });

From a52f2c1fdee5a4c7d24bd06d84666a37cce58650 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 00:59:28 +0100
Subject: [PATCH 09/32] Update: implement getCardValue function to return
 correct card values and add test cases

---
 .../2-mandatory-rewrite/3-get-card-value.js   | 21 ++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/Sprint-3/2-mandatory-rewrite/3-get-card-value.js b/Sprint-3/2-mandatory-rewrite/3-get-card-value.js
index 0d95d3736..41c123a75 100644
--- a/Sprint-3/2-mandatory-rewrite/3-get-card-value.js
+++ b/Sprint-3/2-mandatory-rewrite/3-get-card-value.js
@@ -1,5 +1,20 @@
 function getCardValue(card) {
-    // replace with your code from key-implement
-    return 11;
+  // replace with your code from key-implement
+  //  return 11; // always return 11 for testing purposes that is wrong
+  const rank = card.slice(0, -1); // Extract rank (everything except the last character)
+  if (rank === "A") return 11; // handle Ace as 11
+  if (["K", "Q", "J"].includes(rank)) return 10; // handle face cards as 10
+  const numerincRank = parseInt(rank); //Handle number cards 2–9
+  if (numerincRank >= 2 && numerincRank <= 9) {
+    return numerincRank; // Return the numeric value for cards 2-9
+  }
+  // Invalid card rank
+  return 0;
 }
-module.exports = getCardValue;
\ No newline at end of file
+module.exports = getCardValue;
+
+// // Test cases
+console.log(getCardValue("A♠")); // 11
+console.log(getCardValue("7♥")); // 7
+console.log(getCardValue("K♦")); // 10
+console.log(getCardValue("A♣")); // 11

From e2c54d6df8b5656fdc98b4c8469e0d4ab8058118 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 01:00:14 +0100
Subject: [PATCH 10/32] Update: fix test cases in getCardValue to improve
 readability and consistency

---
 .../3-get-card-value.test.js                  | 22 ++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js b/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js
index 03a8e2f34..a82316add 100644
--- a/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js
+++ b/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js
@@ -1,11 +1,27 @@
 const getCardValue = require("./3-get-card-value");
 
 test("should return 11 for Ace of Spades", () => {
-    const aceofSpades = getCardValue("A♠");
-    expect(aceofSpades).toEqual(11);
-    });
+  const aceofSpades = getCardValue("A♠");
+  expect(aceofSpades).toEqual(11);
+});
 
 // Case 2: Handle Number Cards (2-10):
+test("should return 7 for 7 of Hearts", () => {
+  const sevenOfHearts = getCardValue("7♥");
+  expect(sevenOfHearts).toEqual(7);
+});
 // Case 3: Handle Face Cards (J, Q, K):
+test("should return 10 for King of Diamonds", () => {
+  const kingOfDiamonds = getCardValue("K♦");
+  expect(kingOfDiamonds).toEqual(10);
+});
 // Case 4: Handle Ace (A):
+test("should return 11 for Ace of Clubs", () => {
+  const aceOfClubs = getCardValue("A♣");
+  expect(aceOfClubs).toEqual(11);
+});
 // Case 5: Handle Invalid Cards:
+test("should return 0 for invalid card 'X♠'", () => {
+  const invalidCard = getCardValue("X♠");
+  expect(invalidCard).toEqual(0);
+});

From 101471404a2b321b9d7f11453902828635b0c50a Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 01:06:24 +0100
Subject: [PATCH 11/32] Update: fix countChar function with correct
 implementation and add example usage

---
 Sprint-3/3-mandatory-practice/implement/count.js | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/Sprint-3/3-mandatory-practice/implement/count.js b/Sprint-3/3-mandatory-practice/implement/count.js
index fce249650..2b056aa25 100644
--- a/Sprint-3/3-mandatory-practice/implement/count.js
+++ b/Sprint-3/3-mandatory-practice/implement/count.js
@@ -1,5 +1,11 @@
 function countChar(stringOfCharacters, findCharacter) {
-    return 5
+  // return 5; //This will always return 5, regardless of the inputs. So it’s just a placeholder.
+  return stringOfCharacters.split(findCharacter).length - 1;
 }
 
-module.exports = countChar;
\ No newline at end of file
+module.exports = countChar;
+
+// console.log(countChar("hello", "l")); // 2
+// console.log(countChar("hello world", "o")); // 2
+// console.log(countChar("banana", "a")); // 3
+// console.log(countChar("mississippi", "i")); // 5

From af666321b16db7b5d4aaa6c54550db4ba539837f Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 01:08:51 +0100
Subject: [PATCH 12/32] Update: add test case for countChar function to verify
 function

---
 Sprint-3/3-mandatory-practice/implement/count.test.js | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/Sprint-3/3-mandatory-practice/implement/count.test.js b/Sprint-3/3-mandatory-practice/implement/count.test.js
index 42baf4b4b..165467d59 100644
--- a/Sprint-3/3-mandatory-practice/implement/count.test.js
+++ b/Sprint-3/3-mandatory-practice/implement/count.test.js
@@ -22,3 +22,11 @@ test("should count multiple occurrences of a character", () => {
 // And a character char that does not exist within the case-sensitive str,
 // When the function is called with these inputs,
 // Then it should return 0, indicating that no occurrences of the char were found in the case-sensitive str.
+test("should return 0 when the character is not present", () => {
+  const str = "aaaaa";
+  const char = "z"; // 'z' does not exist in "aaaaa"
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});
+
+module.exports = countChar;

From a5879e7f3e45c497dec5599aeb34429984b6f04c Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 01:09:44 +0100
Subject: [PATCH 13/32] Update: implement getOrdinalNumber function to return
 correct ordinal numbers

---
 .../implement/get-ordinal-number.js           | 27 +++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.js b/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.js
index 24f528b0d..2c5d0e882 100644
--- a/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.js
+++ b/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.js
@@ -1,5 +1,28 @@
 function getOrdinalNumber(num) {
- return "1st";
+  //  return "1st"; //always returns "1st" no matter what input is provided
+  const lastTwo = num % 100;
+  const lastDigit = num % 10;
+  if (lastTwo >= 11 && lastTwo <= 13) {
+    return num + "th";
+  }
+
+  switch (lastDigit) {
+    case 1:
+      return num + "st";
+    case 2:
+      return num + "nd";
+    case 3:
+      return num + "rd";
+    default:
+      return num + "th";
+  }
 }
+module.exports = getOrdinalNumber;
 
-module.exports = getOrdinalNumber;
\ No newline at end of file
+// console.log(getOrdinalNumber(1)); // "1st"
+// console.log(getOrdinalNumber(2)); // "2nd"
+// console.log(getOrdinalNumber(3)); // "3rd"
+// console.log(getOrdinalNumber(4)); // "4th"
+// console.log(getOrdinalNumber(51)); // "51st"
+// console.log(getOrdinalNumber(102)); // "102nd"
+// console.log(getOrdinalNumber(1114)); // "1114th"

From e255a25cc9418f3b1aea884f081f6aaafca7e5b5 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 01:12:00 +0100
Subject: [PATCH 14/32] Update: fix code and test in getOrdinalNumber test case

---
 .../implement/get-ordinal-number.test.js                     | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.test.js b/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.test.js
index 6d55dfbb4..dfa8e44b6 100644
--- a/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.test.js
+++ b/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.test.js
@@ -9,5 +9,6 @@ const getOrdinalNumber = require("./get-ordinal-number");
 // Then the function should return "1st"
 
 test("should return '1st' for 1", () => {
-    expect(getOrdinalNumber(1)).toEqual("1st");
-    });
+  expect(getOrdinalNumber(1)).toEqual("1st");
+});
+console.log(getOrdinalNumber(1));

From 9b9d6facf12672482b44b2c38619d7ade6f6857d Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 01:13:10 +0100
Subject: [PATCH 15/32] Update: fix repeat function to accept parameters and
 handle non-negative integer counts

---
 .../3-mandatory-practice/implement/repeat.js  | 20 ++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/Sprint-3/3-mandatory-practice/implement/repeat.js b/Sprint-3/3-mandatory-practice/implement/repeat.js
index 621f9bd35..ace324344 100644
--- a/Sprint-3/3-mandatory-practice/implement/repeat.js
+++ b/Sprint-3/3-mandatory-practice/implement/repeat.js
@@ -1,5 +1,19 @@
-function repeat() {
-    return "hellohellohello";
+// function repeat() {
+//     return "hellohellohello";
+// }
+// The function always returns "hellohellohello" regardless of any input.
+// There are no parameters, so it’s not flexible or reusable.
+function repeat(str, count) {
+  if (!Number.isInteger(count) || count < 0) {
+    return "Error: Count must be a non-negative integer";
+  }
+  return str.repeat(count);
 }
 
-module.exports = repeat;
\ No newline at end of file
+module.exports = repeat;
+//  Example usage:
+// console.log(repeat("hello", 3)); // Expected: "hellohellohello"
+// console.log(repeat("at", 5)); // Expected: "atatatatat"
+// console.log(repeat("test0", 0)); // Expected: ""
+// console.log(repeat("", 5)); // Expected: ""
+// console.log(repeat("WE", 1)); // Expected: "hi"

From 4c03b27739a6e40b289ef452aad5f9d8cba418a2 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 01:13:54 +0100
Subject: [PATCH 16/32] Update:  test cases in repeat.test.js for clarity

---
 .../implement/repeat.test.js                    | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/Sprint-3/3-mandatory-practice/implement/repeat.test.js b/Sprint-3/3-mandatory-practice/implement/repeat.test.js
index 8a4ab42ef..2df825f68 100644
--- a/Sprint-3/3-mandatory-practice/implement/repeat.test.js
+++ b/Sprint-3/3-mandatory-practice/implement/repeat.test.js
@@ -9,24 +9,25 @@ const repeat = require("./repeat");
 // When the repeat function is called with these inputs,
 // Then it should repeat the str count times and return a new string containing the repeated str values.
 
-test("should repeat the string count times", () => {
-    const str = "hello";
-    const count = 3;
-    const repeatedStr = repeat(str, count);
-    expect(repeatedStr).toEqual("hellohellohello");
-    });
+// test("should repeat the string count times", () => {
+//   const str = "hello";
+//   const count = 3;
+//   const repeatedStr = repeat(str, count);
+//   expect(repeatedStr).toEqual("hellohellohello");
+// });
 
 // case: handle Count of 1:
 // Given a target string str and a count equal to 1,
 // When the repeat function is called with these inputs,
 // Then it should return the original str without repetition, ensuring that a count of 1 results in no repetition.
-
+console.log(repeat("str", 1)); // Expected: "str"
 // case: Handle Count of 0:
 // Given a target string str and a count equal to 0,
 // When the repeat function is called with these inputs,
 // Then it should return an empty string, ensuring that a count of 0 results in an empty output.
-
+console.log(repeat("hello", 0)); // Expected: " "
 // case: Negative Count:
 // Given a target string str and a negative integer count,
 // When the repeat function is called with these inputs,
 // Then it should throw an error or return an appropriate error message, as negative counts are not valid.
+console.log(repeat("hello", -3)); // Expected: "Error: Count must be a non-negative integer"

From d0371be7fe7131c7a621be0fdd1287c72df9f79c Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 01:15:55 +0100
Subject: [PATCH 17/32] Update:  comments foe questions to explain code in
 find.js for better clarity on loop mechanics

---
 Sprint-3/4-stretch-investigate/find.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Sprint-3/4-stretch-investigate/find.js b/Sprint-3/4-stretch-investigate/find.js
index c7e79a2f2..4e16197dc 100644
--- a/Sprint-3/4-stretch-investigate/find.js
+++ b/Sprint-3/4-stretch-investigate/find.js
@@ -20,6 +20,11 @@ console.log(find("code your future", "z"));
 // Pay particular attention to the following:
 
 // a) How the index variable updates during the call to find
+//  increments by 1 in every iteration using index++.
 // b) What is the if statement used to check
+//  checks if the character at the current index matches the specified character.
 // c) Why is index++ being used?
+// It moves the pointer forward through the string. Without it, the loop would run infinitely.
+
 // d) What is the condition index < str.length used for?
+// It ensures we don’t read beyond the string boundary — this prevents errors or undefined behavior.

From 094657bc23febf37ba2a07180af1b886556b5ead Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 01:17:26 +0100
Subject: [PATCH 18/32] Update: fix password validation logic and comment out
 test cases

---
 .../password-validator.js                     | 34 ++++++++++++++++---
 1 file changed, 30 insertions(+), 4 deletions(-)

diff --git a/Sprint-3/4-stretch-investigate/password-validator.js b/Sprint-3/4-stretch-investigate/password-validator.js
index b55d527db..381851b87 100644
--- a/Sprint-3/4-stretch-investigate/password-validator.js
+++ b/Sprint-3/4-stretch-investigate/password-validator.js
@@ -1,6 +1,32 @@
-function passwordValidator(password) {
-    return password.length < 5 ? false : true
-}
+// function passwordValidator(password) {
+//   return password.length < 5 ? false : true;
+// }
+
+// module.exports = passwordValidator;
+const previousPasswords = ["Password123!", "Welcome2023$", "Admin*1"];
 
+function isValidPassword(password) {
+  const hasMinLength = password.length >= 5;
+  const hasUppercase = /[A-Z]/.test(password);
+  const hasLowercase = /[a-z]/.test(password);
+  const hasDigit = /[0-9]/.test(password);
+  const hasSymbol = /[!#$%.*&]/.test(password);
+  const isNotPrevious = !previousPasswords.includes(password);
+
+  return (
+    hasMinLength &&
+    hasUppercase &&
+    hasLowercase &&
+    hasDigit &&
+    hasSymbol &&
+    isNotPrevious
+  );
+}
 
-module.exports = passwordValidator;
\ No newline at end of file
+module.exports = isValidPassword;
+// Example usage:
+// console.log(isValidPassword("Abdi10!")); // true
+// console.log(isValidPassword("12345")); // false
+// console.log(isValidPassword("123")); // false
+// console.log(isValidPassword("abcde")); // false
+// console.log(isValidPassword("")); // false

From d457ddd28613730756e077931189100dec491ae9 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Thu, 3 Jul 2025 01:19:00 +0100
Subject: [PATCH 19/32] Update:  password validation test for consistency and
 clarity

---
 .../password-validator.test.js                | 21 ++++++++++++-------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/Sprint-3/4-stretch-investigate/password-validator.test.js b/Sprint-3/4-stretch-investigate/password-validator.test.js
index 8fa3089d6..d67f22d2d 100644
--- a/Sprint-3/4-stretch-investigate/password-validator.test.js
+++ b/Sprint-3/4-stretch-investigate/password-validator.test.js
@@ -16,11 +16,16 @@ You must breakdown this problem in order to solve it. Find one test case first a
 */
 const isValidPassword = require("./password-validator");
 test("password has at least 5 characters", () => {
-    // Arrange
-    const password = "12345";
-    // Act
-    const result = isValidPassword(password);
-    // Assert
-    expect(result).toEqual(true);
-}
-);
\ No newline at end of file
+  // Arrange
+  const password = "12345";
+  // Act
+  const result = isValidPassword(password);
+  // Assert
+  expect(result).toEqual(true);
+});
+expect(result).toEqual(true);
+const isValidPassword = require("./password-validator");
+// // usage example
+// console.log(isValidPassword("Test123!")); // true
+// console.log(isValidPassword("pass")); // false (too short)
+// console.log(isValidPassword("password")); // false (no number or special character)

From 729f88f5c02884e1529921a20d9780f411dc595e Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Sat, 5 Jul 2025 12:51:16 +0100
Subject: [PATCH 20/32] update: Implement getAngleType function with tests for
 angle classification

---
 Sprint-3/1-key-implement/1-get-angle-type.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sprint-3/1-key-implement/1-get-angle-type.js b/Sprint-3/1-key-implement/1-get-angle-type.js
index 49185fded..7ed5b532d 100644
--- a/Sprint-3/1-key-implement/1-get-angle-type.js
+++ b/Sprint-3/1-key-implement/1-get-angle-type.js
@@ -28,7 +28,7 @@ function assertEquals(actualOutput, targetOutput) {
     `Expected ${actualOutput} to equal ${targetOutput}`
   );
 }
-
+console.log("hello there");
 // Acceptance criteria:
 
 // Given an angle in degrees,

From d17fa1d282b97b0591dc498cb97e6bfe59848625 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Mon, 7 Jul 2025 20:43:37 +0100
Subject: [PATCH 21/32] update: Implement dir and ext extraction logic in
 3-paths.js

---
 Sprint-1/1-key-exercises/3-paths.js | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/Sprint-1/1-key-exercises/3-paths.js b/Sprint-1/1-key-exercises/3-paths.js
index ab90ebb28..78715b24a 100644
--- a/Sprint-1/1-key-exercises/3-paths.js
+++ b/Sprint-1/1-key-exercises/3-paths.js
@@ -17,7 +17,13 @@ console.log(`The base part of ${filePath} is ${base}`);
 // Create a variable to store the dir part of the filePath variable
 // Create a variable to store the ext part of the variable
 
-const dir = ;
-const ext = ;
-
-// https://www.google.com/search?q=slice+mdn
\ No newline at end of file
+const dir = filePath.slice(0, lastSlashIndex);// The code uses the lastIndexOf method to find the position of the last slash in;
+console.log(`The dir part of ${filePath} is ${dir}`);
+filePath.slice(0, lastSlashIndex);
+const ext = filePath;
+filePath
+  .slice(lastSlashIndex + 1)
+  .split(".")
+  .pop();
+// The code above uses the lastIndexOf method to find the position of the last slash in the filePath string.
+// The slice method is then used to extract the base part of the filePath string, which is the part after the last slash.

From affd78a0c91514ea883a66e699426932b20059d5 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Mon, 7 Jul 2025 20:48:46 +0100
Subject: [PATCH 22/32] update: fix ext extraction logic in 3-paths.js

---
 Sprint-1/1-key-exercises/3-paths.js | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/Sprint-1/1-key-exercises/3-paths.js b/Sprint-1/1-key-exercises/3-paths.js
index 78715b24a..e61a1ec75 100644
--- a/Sprint-1/1-key-exercises/3-paths.js
+++ b/Sprint-1/1-key-exercises/3-paths.js
@@ -15,15 +15,17 @@ const base = filePath.slice(lastSlashIndex + 1);
 console.log(`The base part of ${filePath} is ${base}`);
 
 // Create a variable to store the dir part of the filePath variable
-// Create a variable to store the ext part of the variable
+
 
 const dir = filePath.slice(0, lastSlashIndex);// The code uses the lastIndexOf method to find the position of the last slash in;
 console.log(`The dir part of ${filePath} is ${dir}`);
 filePath.slice(0, lastSlashIndex);
-const ext = filePath;
+
 filePath
   .slice(lastSlashIndex + 1)
   .split(".")
   .pop();
-// The code above uses the lastIndexOf method to find the position of the last slash in the filePath string.
-// The slice method is then used to extract the base part of the filePath string, which is the part after the last slash.
+// Create a variable to store the ext part of the variable
+
+const ext=base.slice(base.lastIndexOf(".") + 1);
+console.log(`The ext part of ${filePath} is ${ext}`); 
\ No newline at end of file

From 93fae6464e54326b67100d3eb183d8dbe3a122c6 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Mon, 7 Jul 2025 20:49:22 +0100
Subject: [PATCH 23/32] update: add comment to ext extraction logic for clarity

---
 Sprint-1/1-key-exercises/3-paths.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sprint-1/1-key-exercises/3-paths.js b/Sprint-1/1-key-exercises/3-paths.js
index e61a1ec75..501c0dcfb 100644
--- a/Sprint-1/1-key-exercises/3-paths.js
+++ b/Sprint-1/1-key-exercises/3-paths.js
@@ -27,5 +27,5 @@ filePath
   .pop();
 // Create a variable to store the ext part of the variable
 
-const ext=base.slice(base.lastIndexOf(".") + 1);
+const ext=base.slice(base.lastIndexOf(".") + 1); // The code uses the lastIndexOf method to find the position of the last dot in the base variable.
 console.log(`The ext part of ${filePath} is ${ext}`); 
\ No newline at end of file

From 635a1a0e326b47155dd4468316a0bf96e4913dc6 Mon Sep 17 00:00:00 2001
From: Surafel <surafealaw@gmail.com>
Date: Sat, 12 Jul 2025 11:15:40 +0100
Subject: [PATCH 24/32] Update 3-paths.js

cleaning the comments of sprint-1 works on sprint-3
---
 Sprint-1/1-key-exercises/3-paths.js | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/Sprint-1/1-key-exercises/3-paths.js b/Sprint-1/1-key-exercises/3-paths.js
index 501c0dcfb..433c72934 100644
--- a/Sprint-1/1-key-exercises/3-paths.js
+++ b/Sprint-1/1-key-exercises/3-paths.js
@@ -15,17 +15,9 @@ const base = filePath.slice(lastSlashIndex + 1);
 console.log(`The base part of ${filePath} is ${base}`);
 
 // Create a variable to store the dir part of the filePath variable
-
-
-const dir = filePath.slice(0, lastSlashIndex);// The code uses the lastIndexOf method to find the position of the last slash in;
-console.log(`The dir part of ${filePath} is ${dir}`);
-filePath.slice(0, lastSlashIndex);
-
-filePath
-  .slice(lastSlashIndex + 1)
-  .split(".")
-  .pop();
 // Create a variable to store the ext part of the variable
 
-const ext=base.slice(base.lastIndexOf(".") + 1); // The code uses the lastIndexOf method to find the position of the last dot in the base variable.
-console.log(`The ext part of ${filePath} is ${ext}`); 
\ No newline at end of file
+const dir = ;
+const ext = ;
+
+// https://www.google.com/search?q=slice+mdn

From 2bfd808f5dc4e31df69c4eb5ef6ab1e8e2a993db Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Sat, 12 Jul 2025 13:25:45 +0100
Subject: [PATCH 25/32] changed log statement

---
 Sprint-3/1-key-implement/1-get-angle-type.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sprint-3/1-key-implement/1-get-angle-type.js b/Sprint-3/1-key-implement/1-get-angle-type.js
index 7ed5b532d..d7867ba4b 100644
--- a/Sprint-3/1-key-implement/1-get-angle-type.js
+++ b/Sprint-3/1-key-implement/1-get-angle-type.js
@@ -28,7 +28,7 @@ function assertEquals(actualOutput, targetOutput) {
     `Expected ${actualOutput} to equal ${targetOutput}`
   );
 }
-console.log("hello there");
+console.log("hello");
 // Acceptance criteria:
 
 // Given an angle in degrees,

From 7c6010a4db587f80dc2219464aa9546a8e051444 Mon Sep 17 00:00:00 2001
From: Surafel <surafealaw@gmail.com>
Date: Mon, 14 Jul 2025 00:00:01 +0100
Subject: [PATCH 26/32] Update 3-get-card-value.js

spelling correcetion
---
 Sprint-3/2-mandatory-rewrite/3-get-card-value.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Sprint-3/2-mandatory-rewrite/3-get-card-value.js b/Sprint-3/2-mandatory-rewrite/3-get-card-value.js
index 41c123a75..db30980bf 100644
--- a/Sprint-3/2-mandatory-rewrite/3-get-card-value.js
+++ b/Sprint-3/2-mandatory-rewrite/3-get-card-value.js
@@ -4,9 +4,9 @@ function getCardValue(card) {
   const rank = card.slice(0, -1); // Extract rank (everything except the last character)
   if (rank === "A") return 11; // handle Ace as 11
   if (["K", "Q", "J"].includes(rank)) return 10; // handle face cards as 10
-  const numerincRank = parseInt(rank); //Handle number cards 2–9
-  if (numerincRank >= 2 && numerincRank <= 9) {
-    return numerincRank; // Return the numeric value for cards 2-9
+  const numericRank = parseInt(rank); //Handle number cards 2–9
+  if (numericRank >= 2 && numericRank <= 9) {
+    return numericRank; // Return the numeric value for cards 2-9
   }
   // Invalid card rank
   return 0;

From eed725e48d1c4222e229487b1f2d95071dc9bd66 Mon Sep 17 00:00:00 2001
From: Surafel <surafealaw@gmail.com>
Date: Mon, 14 Jul 2025 00:23:36 +0100
Subject: [PATCH 27/32] Update 2-is-proper-fraction.js

add condition to heck if denominator is zero
---
 Sprint-3/1-key-implement/2-is-proper-fraction.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Sprint-3/1-key-implement/2-is-proper-fraction.js b/Sprint-3/1-key-implement/2-is-proper-fraction.js
index 25112cb4a..a6dea1f9f 100644
--- a/Sprint-3/1-key-implement/2-is-proper-fraction.js
+++ b/Sprint-3/1-key-implement/2-is-proper-fraction.js
@@ -8,6 +8,10 @@
 // write one test at a time, and make it pass, build your solution up methodically
 
 function isProperFraction(numerator, denominator) {
+  if (denominator === 0) {
+    // Denominator can't be zero in a valid fraction
+    return false;
+  }
   // if (numerator < denominator) return true; it will not work for negative numbers
   return Math.abs(numerator) < Math.abs(denominator);
 }

From 9c478cdecbc19ed36c82971a5677292a26d5f4b3 Mon Sep 17 00:00:00 2001
From: Surafel <surafealaw@gmail.com>
Date: Mon, 14 Jul 2025 00:29:07 +0100
Subject: [PATCH 28/32] Update count.test.js

cleaning code line
---
 Sprint-3/3-mandatory-practice/implement/count.test.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sprint-3/3-mandatory-practice/implement/count.test.js b/Sprint-3/3-mandatory-practice/implement/count.test.js
index 165467d59..54074fc6f 100644
--- a/Sprint-3/3-mandatory-practice/implement/count.test.js
+++ b/Sprint-3/3-mandatory-practice/implement/count.test.js
@@ -29,4 +29,4 @@ test("should return 0 when the character is not present", () => {
   expect(count).toEqual(0);
 });
 
-module.exports = countChar;
+

From 8cb7495d3577228c8e6f4aa7c97788c9bf2a972d Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Mon, 14 Jul 2025 22:41:05 +0100
Subject: [PATCH 29/32] update: include code for denominator must not be zero

---
 Sprint-3/1-key-implement/2-is-proper-fraction.js | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/Sprint-3/1-key-implement/2-is-proper-fraction.js b/Sprint-3/1-key-implement/2-is-proper-fraction.js
index a6dea1f9f..b236d5de7 100644
--- a/Sprint-3/1-key-implement/2-is-proper-fraction.js
+++ b/Sprint-3/1-key-implement/2-is-proper-fraction.js
@@ -8,11 +8,9 @@
 // write one test at a time, and make it pass, build your solution up methodically
 
 function isProperFraction(numerator, denominator) {
-  if (denominator === 0) {
-    // Denominator can't be zero in a valid fraction
-    return false;
-  }
-  // if (numerator < denominator) return true; it will not work for negative numbers
+  if (numerator < denominator) return true; //it will  is proper fraction
+  if (denominator === 0) return false; // Denominator cannot be zero
+  
   return Math.abs(numerator) < Math.abs(denominator);
 }
 

From 14e256e9048701a698369abad58dbdf508921569 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Mon, 14 Jul 2025 23:55:02 +0100
Subject: [PATCH 30/32] update: testing case1 count times

---
 .../3-mandatory-practice/implement/repeat.test.js    | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Sprint-3/3-mandatory-practice/implement/repeat.test.js b/Sprint-3/3-mandatory-practice/implement/repeat.test.js
index 2df825f68..5a41e6f5d 100644
--- a/Sprint-3/3-mandatory-practice/implement/repeat.test.js
+++ b/Sprint-3/3-mandatory-practice/implement/repeat.test.js
@@ -9,12 +9,12 @@ const repeat = require("./repeat");
 // When the repeat function is called with these inputs,
 // Then it should repeat the str count times and return a new string containing the repeated str values.
 
-// test("should repeat the string count times", () => {
-//   const str = "hello";
-//   const count = 3;
-//   const repeatedStr = repeat(str, count);
-//   expect(repeatedStr).toEqual("hellohellohello");
-// });
+test("should repeat the string count times", () => {
+  const str = "hello";
+  const count = 3;
+  const repeatedStr = repeat(str, count);
+  expect(repeatedStr).toEqual("hellohellohello");
+});
 
 // case: handle Count of 1:
 // Given a target string str and a count equal to 1,

From 922ebf5ba21dd3ec4893dd12170328a996fe52a2 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Tue, 15 Jul 2025 01:14:48 +0100
Subject: [PATCH 31/32] update: test cases for repeat.test.js

---
 .../implement/repeat.test.js                  | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/Sprint-3/3-mandatory-practice/implement/repeat.test.js b/Sprint-3/3-mandatory-practice/implement/repeat.test.js
index 5a41e6f5d..e08c08606 100644
--- a/Sprint-3/3-mandatory-practice/implement/repeat.test.js
+++ b/Sprint-3/3-mandatory-practice/implement/repeat.test.js
@@ -20,14 +20,33 @@ test("should repeat the string count times", () => {
 // Given a target string str and a count equal to 1,
 // When the repeat function is called with these inputs,
 // Then it should return the original str without repetition, ensuring that a count of 1 results in no repetition.
+test("should repeat the string count 1 times", () => {
+  const str = "str";
+  const count = 1;
+  const repeatedStr = repeat(str, count);
+  expect(repeatedStr).toEqual("str");
+});
 console.log(repeat("str", 1)); // Expected: "str"
 // case: Handle Count of 0:
 // Given a target string str and a count equal to 0,
 // When the repeat function is called with these inputs,
 // Then it should return an empty string, ensuring that a count of 0 results in an empty output.
 console.log(repeat("hello", 0)); // Expected: " "
+
+test("should repeat the string count 0 times", () => {
+  const str = "hello";
+  const count = 0;
+  const repeatedStr = repeat(str, count);
+  expect(repeatedStr).toEqual("");
+});
 // case: Negative Count:
 // Given a target string str and a negative integer count,
 // When the repeat function is called with these inputs,
 // Then it should throw an error or return an appropriate error message, as negative counts are not valid.
 console.log(repeat("hello", -3)); // Expected: "Error: Count must be a non-negative integer"
+test("should repeat the string count -3 times", () => {
+  const str = "hello";
+  const count = -3;
+  const repeatedStr = repeat(str, count);
+  expect(repeatedStr).toEqual("Error: Count must be a non-negative integer");
+});
\ No newline at end of file

From ddf577da1dbba08ffbd7797ca905bfa2fed0c7c4 Mon Sep 17 00:00:00 2001
From: SuWebOnes <surafealaw@gmail.com>
Date: Tue, 15 Jul 2025 01:48:43 +0100
Subject: [PATCH 32/32] update: fix password validation tests for minimum
 length, reused and missing symbol

---
 .../password-validator.test.js                | 23 +++++++++++++------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/Sprint-3/4-stretch-investigate/password-validator.test.js b/Sprint-3/4-stretch-investigate/password-validator.test.js
index d67f22d2d..aeb925d14 100644
--- a/Sprint-3/4-stretch-investigate/password-validator.test.js
+++ b/Sprint-3/4-stretch-investigate/password-validator.test.js
@@ -21,11 +21,20 @@ test("password has at least 5 characters", () => {
   // Act
   const result = isValidPassword(password);
   // Assert
-  expect(result).toEqual(true);
+  expect(result).toEqual(false);
 });
-expect(result).toEqual(true);
-const isValidPassword = require("./password-validator");
-// // usage example
-// console.log(isValidPassword("Test123!")); // true
-// console.log(isValidPassword("pass")); // false (too short)
-// console.log(isValidPassword("password")); // false (no number or special character)
+
+// TEST 4: Missing symbol
+// Should fail because there is no special character
+test("fails if missing symbol", () => {
+  const password = "Hello123";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false);
+});
+// TEST 6: Common/reused password (if your logic rejects common ones)
+// Should fail because the password is too common (if that rule is included)
+test("fails if reused/common password", () => {
+  const password = "Password123!";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false); // Update this only if your validator handles common passwords
+});
\ No newline at end of file