From 038bb6a8f5de5d9baf1e1c728d28f8b33d997fb5 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Tue, 13 Oct 2026 23:11:09 +0100
Subject: [PATCH 01/19] updating count.js file

---
 practice-tdd/count.js | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/practice-tdd/count.js b/practice-tdd/count.js
index 5518c5712..ae98c6a43 100644
--- a/practice-tdd/count.js
+++ b/practice-tdd/count.js
@@ -1,3 +1,9 @@
 export function countChar(stringOfCharacters, findCharacter) {
-  return 5
+  let count = 0;
+  for (const character of stringOfCharacters) {
+    if (character === findCharacter) {
+      count++;
+    }
+  }
+  return count;
 }

From 7f77ed182645b7f5fddf7dc7c7fd6727871cdcd2 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Tue, 13 Oct 2026 23:14:22 +0100
Subject: [PATCH 02/19] solve excersise count.test.js

---
 practice-tdd/count.test.js | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/practice-tdd/count.test.js b/practice-tdd/count.test.js
index cb3aaae59..7c99146d1 100644
--- a/practice-tdd/count.test.js
+++ b/practice-tdd/count.test.js
@@ -1,5 +1,7 @@
 // implement a function countChar that counts the number of times a character occurs in a string
 import { countChar } from "./count.js";
+import { test, expect } from "@jest/globals";
+
 // Given a string `str` and a single character `char` to search for,
 // When the countChar function is called with these inputs,
 // Then it should:
@@ -22,3 +24,10 @@ test("should count multiple occurrences of a character", () => {
 // And a character `char` that does not exist within `str`.
 // When the function is called with these inputs,
 // Then it should return 0, indicating that no occurrences of `char` were found.
+
+test("should indicate no occurrences of a character", () => {
+  const str = "abcde";
+  const char = "f";
+  const numberOfOcurrence = countChar(str, char);
+  expect(numberOfOcurrence).toEqual(0);
+});

From eafa02b71a93f51e0c9ccb218232a53330c53e95 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Tue, 13 Oct 2026 23:15:42 +0100
Subject: [PATCH 03/19] solve excersise get-ordinal-number.js

---
 practice-tdd/get-ordinal-number.js | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/practice-tdd/get-ordinal-number.js b/practice-tdd/get-ordinal-number.js
index 5c6291f5e..de67a06fe 100644
--- a/practice-tdd/get-ordinal-number.js
+++ b/practice-tdd/get-ordinal-number.js
@@ -1,3 +1,12 @@
 export function getOrdinalNumber(num) {
-  return "1st";
+  if (String(num).match(/\b(?!11\b)\d*1\b/)) {
+    return `${num}st`;
+  }
+  if (String(num).match(/\b(?!12\b)\d*2\b/)) {
+    return `${num}nd`;
+  }
+  if (String(num).match(/\b(?!13\b)\d*3\b/)) {
+    return `${num}rd`;
+  }
+  return `${num}th`;
 }

From d48367cc26d2a17a8f73c875fc6719ff55fabf77 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Tue, 13 Oct 2026 23:17:00 +0100
Subject: [PATCH 04/19] solve excersise get-ordinal-number.test.js

---
 practice-tdd/get-ordinal-number.test.js | 30 +++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/practice-tdd/get-ordinal-number.test.js b/practice-tdd/get-ordinal-number.test.js
index e23174a18..aa959265c 100644
--- a/practice-tdd/get-ordinal-number.test.js
+++ b/practice-tdd/get-ordinal-number.test.js
@@ -18,3 +18,33 @@ test("should append 'st' for numbers ending with 1, except those ending with 11"
   expect(getOrdinalNumber(21)).toEqual("21st");
   expect(getOrdinalNumber(131)).toEqual("131st");
 });
+
+// Case 2: Numbers ending with 2 (but not 12)
+// When the number ends with 2, except those ending with 12,
+// Then the function should return a string by appending "nd" to the number.
+test("should append 'nd' for numbers ending with 2, except those ending with 12", () => {
+  expect(getOrdinalNumber(2)).toEqual("2nd");
+  expect(getOrdinalNumber(32)).toEqual("32nd");
+  expect(getOrdinalNumber(452)).toEqual("452nd");
+});
+
+// Case 3: Numbers ending with 3 (but not 13)
+// When the number ends with 3, except those ending with 13,
+// Then the function should return a string by appending "rd" to the number.
+test("should append 'rd' for numbers ending with 3, except those ending with 13", () => {
+  expect(getOrdinalNumber(3)).toEqual("3rd");
+  expect(getOrdinalNumber(43)).toEqual("43rd");
+  expect(getOrdinalNumber(823)).toEqual("823rd");
+});
+
+// Case 4: Numbers ending with any other number (but not 1,2 or 3)
+// When the number ends with 4,5,6 ,7 ,8 or 9 ,
+// Then the function should return a string by appending "th" to the number.
+test("should append 'th' for numbers ending with 4,5,6 ,7 ,8 or 9 ", () => {
+  expect(getOrdinalNumber(4)).toEqual("4th");
+  expect(getOrdinalNumber(25)).toEqual("25th");
+  expect(getOrdinalNumber(656)).toEqual("656th");
+  expect(getOrdinalNumber(1007)).toEqual("1007th");
+  expect(getOrdinalNumber(638398)).toEqual("638398th");
+  expect(getOrdinalNumber(34454559)).toEqual("34454559th");
+});

From 81f14c51e622d87fe2bdcd6cb26bffdfb7958bc3 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Tue, 13 Oct 2026 23:18:32 +0100
Subject: [PATCH 05/19] solve excersise repeat-str.js

---
 practice-tdd/repeat-str.js | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/practice-tdd/repeat-str.js b/practice-tdd/repeat-str.js
index af273f3b0..fad1597ae 100644
--- a/practice-tdd/repeat-str.js
+++ b/practice-tdd/repeat-str.js
@@ -1,5 +1,14 @@
-export function repeatStr() {
+export function repeatStr(str, count) {
   // Your implementation of this function must *not* call String.prototype.repeat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat).
   // The goal is to re-implement that function, not to use it.
-  return "hellohellohello";
+  if (count < 0) {
+    return "Error! negative counts are not valid";
+  }
+  let result = "";
+  let counter = count;
+  while (counter > 0) {
+    result += str;
+    counter--;
+  }
+  return result;
 }

From e69b86de0ddc1b0afce5e739a6338872d0fdfb0c Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Tue, 13 Oct 2026 23:19:47 +0100
Subject: [PATCH 06/19] solve excersise repeat-str.test.js

---
 practice-tdd/repeat-str.test.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/practice-tdd/repeat-str.test.js b/practice-tdd/repeat-str.test.js
index 8a7036102..2f2849829 100644
--- a/practice-tdd/repeat-str.test.js
+++ b/practice-tdd/repeat-str.test.js
@@ -21,12 +21,33 @@ test("should repeat the string count times", () => {
 // When the repeatStr function is called with these inputs,
 // Then it should return the original `str` without repetition.
 
+test("should return the original `str` without repetition", () => {
+  const str = "hello";
+  const count = 1;
+  const repeatedStr = repeatStr(str, count);
+  expect(repeatedStr).toEqual("hello");
+});
+
 // Case: Handle count of 0:
 // Given a target string `str` and a `count` equal to 0,
 // When the repeatStr function is called with these inputs,
 // Then it should return an empty string.
 
+test("should return an empty string", () => {
+  const str = "hello";
+  const count = 0;
+  const repeatedStr = repeatStr(str, count);
+  expect(repeatedStr).toEqual("");
+});
+
 // Case: Handle negative count:
 // Given a target string `str` and a negative integer `count`,
 // When the repeatStr function is called with these inputs,
 // Then it should throw an error, as negative counts are not valid.
+
+test("should throw an error, as negative counts are not valid.", () => {
+  const str = "hello";
+  const count = -3;
+  const repeatedStr = repeatStr(str, count);
+  expect(repeatedStr).toEqual("Error! negative counts are not valid");
+});

From fa692ca18ec84d72e2eb4234ac81f01d3ddfeb46 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Tue, 13 Oct 2026 23:23:09 +0100
Subject: [PATCH 07/19] addinkg .gitignore

---
 practice-tdd/.gitignore | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 practice-tdd/.gitignore

diff --git a/practice-tdd/.gitignore b/practice-tdd/.gitignore
new file mode 100644
index 000000000..ad5e45ccc
--- /dev/null
+++ b/practice-tdd/.gitignore
@@ -0,0 +1,3 @@
+node_modules
+package.json
+package-lock.json
\ No newline at end of file

From 119d10a1b5ce1da57e95766b27a3f583995aba61 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Wed, 14 Oct 2026 21:31:09 +0100
Subject: [PATCH 08/19]  remove pakage.json and lock files from gitignore

---
 practice-tdd/.gitignore | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/practice-tdd/.gitignore b/practice-tdd/.gitignore
index ad5e45ccc..a56a7ef43 100644
--- a/practice-tdd/.gitignore
+++ b/practice-tdd/.gitignore
@@ -1,3 +1,2 @@
 node_modules
-package.json
-package-lock.json
\ No newline at end of file
+

From c6ff9441508e8611c1be4f2617aca33dbd90cb4c Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Wed, 14 Oct 2026 21:53:07 +0100
Subject: [PATCH 09/19] adding toThrow method

---
 practice-tdd/repeat-str.js      | 2 +-
 practice-tdd/repeat-str.test.js | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/practice-tdd/repeat-str.js b/practice-tdd/repeat-str.js
index fad1597ae..b5753a858 100644
--- a/practice-tdd/repeat-str.js
+++ b/practice-tdd/repeat-str.js
@@ -2,7 +2,7 @@ export function repeatStr(str, count) {
   // Your implementation of this function must *not* call String.prototype.repeat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat).
   // The goal is to re-implement that function, not to use it.
   if (count < 0) {
-    return "Error! negative counts are not valid";
+    throw new Error("Error! negative counts are not valid");
   }
   let result = "";
   let counter = count;
diff --git a/practice-tdd/repeat-str.test.js b/practice-tdd/repeat-str.test.js
index 2f2849829..741f4db70 100644
--- a/practice-tdd/repeat-str.test.js
+++ b/practice-tdd/repeat-str.test.js
@@ -48,6 +48,7 @@ test("should return an empty string", () => {
 test("should throw an error, as negative counts are not valid.", () => {
   const str = "hello";
   const count = -3;
-  const repeatedStr = repeatStr(str, count);
-  expect(repeatedStr).toEqual("Error! negative counts are not valid");
+  expect(() => repeatStr(str, count)).toThrow(
+    "Error! negative counts are not valid"
+  );
 });

From d5f0650068368f6a673b83a2913e3cddac1a757c Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Wed, 14 Oct 2026 22:51:56 +0100
Subject: [PATCH 10/19] update get-ordinal exercise

---
 practice-tdd/get-ordinal-number.js      | 23 +++++++++++++++--------
 practice-tdd/get-ordinal-number.test.js | 10 ++++++++++
 2 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/practice-tdd/get-ordinal-number.js b/practice-tdd/get-ordinal-number.js
index de67a06fe..60d5e0e54 100644
--- a/practice-tdd/get-ordinal-number.js
+++ b/practice-tdd/get-ordinal-number.js
@@ -1,12 +1,19 @@
 export function getOrdinalNumber(num) {
-  if (String(num).match(/\b(?!11\b)\d*1\b/)) {
-    return `${num}st`;
+  const lastTwoDigits = num % 100;
+
+  // Handle exceptions: 11th, 12th, 13th, 111th, etc.
+  if (lastTwoDigits >= 11 && lastTwoDigits <= 13) {
+    return `${num}th`;
   }
-  if (String(num).match(/\b(?!12\b)\d*2\b/)) {
-    return `${num}nd`;
+
+  switch (num % 10) {
+    case 1:
+      return `${num}st`;
+    case 2:
+      return `${num}nd`;
+    case 3:
+      return `${num}rd`;
+    default:
+      return `${num}th`;
   }
-  if (String(num).match(/\b(?!13\b)\d*3\b/)) {
-    return `${num}rd`;
-  }
-  return `${num}th`;
 }
diff --git a/practice-tdd/get-ordinal-number.test.js b/practice-tdd/get-ordinal-number.test.js
index aa959265c..ec414bee3 100644
--- a/practice-tdd/get-ordinal-number.test.js
+++ b/practice-tdd/get-ordinal-number.test.js
@@ -48,3 +48,13 @@ test("should append 'th' for numbers ending with 4,5,6 ,7 ,8 or 9 ", () => {
   expect(getOrdinalNumber(638398)).toEqual("638398th");
   expect(getOrdinalNumber(34454559)).toEqual("34454559th");
 });
+
+// Case 5: Numbers ending with 3digit teen expcetions 
+// When the number ends with ,(111, 112,113)
+// Then the function should return a string by appending "th" to the number.
+test("should append 'th' for numbers ending with ", () => {
+  expect(getOrdinalNumber(111)).toEqual("111th");
+  expect(getOrdinalNumber(112)).toEqual("112th");
+  expect(getOrdinalNumber(113)).toEqual("113th");
+  
+});

From fec0df197eeb10e30bca8cc1f46471da2eca86bd Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Wed, 14 Oct 2026 22:53:34 +0100
Subject: [PATCH 11/19] remove unnessarry import from count.test.js

---
 practice-tdd/count.test.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/practice-tdd/count.test.js b/practice-tdd/count.test.js
index 7c99146d1..97e9bd820 100644
--- a/practice-tdd/count.test.js
+++ b/practice-tdd/count.test.js
@@ -1,6 +1,5 @@
 // implement a function countChar that counts the number of times a character occurs in a string
 import { countChar } from "./count.js";
-import { test, expect } from "@jest/globals";
 
 // Given a string `str` and a single character `char` to search for,
 // When the countChar function is called with these inputs,

From cfd965b0258793ced97ecd0b2198fd1c5ea431fd Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Wed, 14 Oct 2026 22:56:19 +0100
Subject: [PATCH 12/19] correcting spelling typo

---
 practice-tdd/count.test.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/practice-tdd/count.test.js b/practice-tdd/count.test.js
index 97e9bd820..d06f72bf1 100644
--- a/practice-tdd/count.test.js
+++ b/practice-tdd/count.test.js
@@ -27,6 +27,6 @@ test("should count multiple occurrences of a character", () => {
 test("should indicate no occurrences of a character", () => {
   const str = "abcde";
   const char = "f";
-  const numberOfOcurrence = countChar(str, char);
-  expect(numberOfOcurrence).toEqual(0);
+  const numberOfOccurrence = countChar(str, char);
+  expect(numberOfOccurrence).toEqual(0);
 });

From c5e9432315dd5f40dfe0a49a52dbac3c62cd4e2a Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Mon, 26 Oct 2026 21:26:23 +0000
Subject: [PATCH 13/19]  adding test case handling the special cases like
 11,12,13,101 & 103

---
 practice-tdd/get-ordinal-number.test.js | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/practice-tdd/get-ordinal-number.test.js b/practice-tdd/get-ordinal-number.test.js
index ec414bee3..f417a1ead 100644
--- a/practice-tdd/get-ordinal-number.test.js
+++ b/practice-tdd/get-ordinal-number.test.js
@@ -1,4 +1,5 @@
 import { getOrdinalNumber } from "./get-ordinal-number.js";
+
 // In this week's prep, we started implementing getOrdinalNumber.
 
 // Continue testing and implementing getOrdinalNumber for additional cases.
@@ -52,9 +53,22 @@ test("should append 'th' for numbers ending with 4,5,6 ,7 ,8 or 9 ", () => {
 // Case 5: Numbers ending with 3digit teen expcetions 
 // When the number ends with ,(111, 112,113)
 // Then the function should return a string by appending "th" to the number.
-test("should append 'th' for numbers ending with ", () => {
+test("should append 'th' for numbers in 100's ending with 11, 12 , 13", () => {
   expect(getOrdinalNumber(111)).toEqual("111th");
   expect(getOrdinalNumber(112)).toEqual("112th");
   expect(getOrdinalNumber(113)).toEqual("113th");
   
 });
+
+
+// Case 6:A test case handling the special cases like 11,12,13,101 & 103 
+
+
+test("should append 'th' for numbers ending with ", () => {
+  expect(getOrdinalNumber(11)).toEqual("11th");
+  expect(getOrdinalNumber(12)).toEqual("12th");
+  expect(getOrdinalNumber(13)).toEqual("13th");
+   expect(getOrdinalNumber(101)).toEqual("101st");
+   expect(getOrdinalNumber(103)).toEqual("103rd");
+  
+});

From 9221e650c3af159660e9b85f132ce7546d1cd0f4 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Mon, 26 Oct 2026 21:29:44 +0000
Subject: [PATCH 14/19] delete gitignore file

---
 practice-tdd/.gitignore | 2 --
 1 file changed, 2 deletions(-)
 delete mode 100644 practice-tdd/.gitignore

diff --git a/practice-tdd/.gitignore b/practice-tdd/.gitignore
deleted file mode 100644
index a56a7ef43..000000000
--- a/practice-tdd/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-node_modules
-

From 37f772e2c51cd91cfa780f5d8700dbb04ac20ba1 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Mon, 26 Oct 2026 21:39:37 +0000
Subject: [PATCH 15/19] adding multiple sample test in each category

---
 practice-tdd/get-ordinal-number.test.js | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/practice-tdd/get-ordinal-number.test.js b/practice-tdd/get-ordinal-number.test.js
index f417a1ead..d72908428 100644
--- a/practice-tdd/get-ordinal-number.test.js
+++ b/practice-tdd/get-ordinal-number.test.js
@@ -26,7 +26,9 @@ test("should append 'st' for numbers ending with 1, except those ending with 11"
 test("should append 'nd' for numbers ending with 2, except those ending with 12", () => {
   expect(getOrdinalNumber(2)).toEqual("2nd");
   expect(getOrdinalNumber(32)).toEqual("32nd");
+  expect(getOrdinalNumber(72)).toEqual("72nd");
   expect(getOrdinalNumber(452)).toEqual("452nd");
+  expect(getOrdinalNumber(862)).toEqual("862nd");
 });
 
 // Case 3: Numbers ending with 3 (but not 13)
@@ -35,7 +37,9 @@ test("should append 'nd' for numbers ending with 2, except those ending with 12"
 test("should append 'rd' for numbers ending with 3, except those ending with 13", () => {
   expect(getOrdinalNumber(3)).toEqual("3rd");
   expect(getOrdinalNumber(43)).toEqual("43rd");
+   expect(getOrdinalNumber(93)).toEqual("93rd");
   expect(getOrdinalNumber(823)).toEqual("823rd");
+   expect(getOrdinalNumber(183)).toEqual("183rd");
 });
 
 // Case 4: Numbers ending with any other number (but not 1,2 or 3)
@@ -50,25 +54,21 @@ test("should append 'th' for numbers ending with 4,5,6 ,7 ,8 or 9 ", () => {
   expect(getOrdinalNumber(34454559)).toEqual("34454559th");
 });
 
-// Case 5: Numbers ending with 3digit teen expcetions 
+// Case 5: Numbers ending with 3digit teen expcetions
 // When the number ends with ,(111, 112,113)
 // Then the function should return a string by appending "th" to the number.
 test("should append 'th' for numbers in 100's ending with 11, 12 , 13", () => {
   expect(getOrdinalNumber(111)).toEqual("111th");
   expect(getOrdinalNumber(112)).toEqual("112th");
   expect(getOrdinalNumber(113)).toEqual("113th");
-  
 });
 
-
-// Case 6:A test case handling the special cases like 11,12,13,101 & 103 
-
+// Case 6:A test case handling the special cases like 11,12,13,101 & 103
 
 test("should append 'th' for numbers ending with ", () => {
   expect(getOrdinalNumber(11)).toEqual("11th");
   expect(getOrdinalNumber(12)).toEqual("12th");
   expect(getOrdinalNumber(13)).toEqual("13th");
-   expect(getOrdinalNumber(101)).toEqual("101st");
-   expect(getOrdinalNumber(103)).toEqual("103rd");
-  
+  expect(getOrdinalNumber(101)).toEqual("101st");
+  expect(getOrdinalNumber(103)).toEqual("103rd");
 });

From a450f9226dca048718c0d88f6a3ba5d9e4fc2a3b Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Mon, 26 Oct 2026 21:55:53 +0000
Subject: [PATCH 16/19] adding an empty string test case

---
 practice-tdd/get-ordinal-number.js      | 5 +++++
 practice-tdd/get-ordinal-number.test.js | 8 +++++++-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/practice-tdd/get-ordinal-number.js b/practice-tdd/get-ordinal-number.js
index 60d5e0e54..182679379 100644
--- a/practice-tdd/get-ordinal-number.js
+++ b/practice-tdd/get-ordinal-number.js
@@ -1,4 +1,9 @@
 export function getOrdinalNumber(num) {
+  //handle a non number inputs
+  if (!num) {
+    return "";
+  }
+
   const lastTwoDigits = num % 100;
 
   // Handle exceptions: 11th, 12th, 13th, 111th, etc.
diff --git a/practice-tdd/get-ordinal-number.test.js b/practice-tdd/get-ordinal-number.test.js
index d72908428..ec1f82dc8 100644
--- a/practice-tdd/get-ordinal-number.test.js
+++ b/practice-tdd/get-ordinal-number.test.js
@@ -65,10 +65,16 @@ test("should append 'th' for numbers in 100's ending with 11, 12 , 13", () => {
 
 // Case 6:A test case handling the special cases like 11,12,13,101 & 103
 
-test("should append 'th' for numbers ending with ", () => {
+test("should append 'th' for numbers for 11,12,13 and 'st' for 101 and 'rd' for 103", () => {
   expect(getOrdinalNumber(11)).toEqual("11th");
   expect(getOrdinalNumber(12)).toEqual("12th");
   expect(getOrdinalNumber(13)).toEqual("13th");
   expect(getOrdinalNumber(101)).toEqual("101st");
   expect(getOrdinalNumber(103)).toEqual("103rd");
 });
+
+
+test("should return empty string if empty string is passed", () => {
+  expect(getOrdinalNumber("")).toEqual("");
+ 
+});

From 64feba557f3785b9b3801c53f33b5c5d2ed22948 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Mon, 26 Oct 2026 22:10:26 +0000
Subject: [PATCH 17/19] remove repeated comments to avoid redendancy

---
 practice-tdd/get-ordinal-number.test.js | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

diff --git a/practice-tdd/get-ordinal-number.test.js b/practice-tdd/get-ordinal-number.test.js
index ec1f82dc8..a9494ac93 100644
--- a/practice-tdd/get-ordinal-number.test.js
+++ b/practice-tdd/get-ordinal-number.test.js
@@ -11,18 +11,14 @@ import { getOrdinalNumber } from "./get-ordinal-number.js";
 // into meaningful categories. Then, select representative samples from each category to test.
 // This approach improves coverage and makes our tests easier to maintain.
 
-// Case 1: Numbers ending with 1 (but not 11)
-// When the number ends with 1, except those ending with 11,
-// Then the function should return a string by appending "st" to the number.
+// Case 1: 
 test("should append 'st' for numbers ending with 1, except those ending with 11", () => {
   expect(getOrdinalNumber(1)).toEqual("1st");
   expect(getOrdinalNumber(21)).toEqual("21st");
   expect(getOrdinalNumber(131)).toEqual("131st");
 });
 
-// Case 2: Numbers ending with 2 (but not 12)
-// When the number ends with 2, except those ending with 12,
-// Then the function should return a string by appending "nd" to the number.
+// Case 2:
 test("should append 'nd' for numbers ending with 2, except those ending with 12", () => {
   expect(getOrdinalNumber(2)).toEqual("2nd");
   expect(getOrdinalNumber(32)).toEqual("32nd");
@@ -31,9 +27,7 @@ test("should append 'nd' for numbers ending with 2, except those ending with 12"
   expect(getOrdinalNumber(862)).toEqual("862nd");
 });
 
-// Case 3: Numbers ending with 3 (but not 13)
-// When the number ends with 3, except those ending with 13,
-// Then the function should return a string by appending "rd" to the number.
+// Case 3: N
 test("should append 'rd' for numbers ending with 3, except those ending with 13", () => {
   expect(getOrdinalNumber(3)).toEqual("3rd");
   expect(getOrdinalNumber(43)).toEqual("43rd");
@@ -42,9 +36,7 @@ test("should append 'rd' for numbers ending with 3, except those ending with 13"
    expect(getOrdinalNumber(183)).toEqual("183rd");
 });
 
-// Case 4: Numbers ending with any other number (but not 1,2 or 3)
-// When the number ends with 4,5,6 ,7 ,8 or 9 ,
-// Then the function should return a string by appending "th" to the number.
+// Case 4: 
 test("should append 'th' for numbers ending with 4,5,6 ,7 ,8 or 9 ", () => {
   expect(getOrdinalNumber(4)).toEqual("4th");
   expect(getOrdinalNumber(25)).toEqual("25th");
@@ -54,9 +46,7 @@ test("should append 'th' for numbers ending with 4,5,6 ,7 ,8 or 9 ", () => {
   expect(getOrdinalNumber(34454559)).toEqual("34454559th");
 });
 
-// Case 5: Numbers ending with 3digit teen expcetions
-// When the number ends with ,(111, 112,113)
-// Then the function should return a string by appending "th" to the number.
+// Case 5: 
 test("should append 'th' for numbers in 100's ending with 11, 12 , 13", () => {
   expect(getOrdinalNumber(111)).toEqual("111th");
   expect(getOrdinalNumber(112)).toEqual("112th");

From d31066ad385f57816e0ffffaedccd30f54c17923 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Mon, 26 Oct 2026 22:19:08 +0000
Subject: [PATCH 18/19] give a better description to test cases

---
 practice-tdd/repeat-str.test.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/practice-tdd/repeat-str.test.js b/practice-tdd/repeat-str.test.js
index 741f4db70..ff6d452f2 100644
--- a/practice-tdd/repeat-str.test.js
+++ b/practice-tdd/repeat-str.test.js
@@ -9,7 +9,7 @@ import { repeatStr } from "./repeat-str.js";
 // When the repeatStr function is called with these inputs,
 // Then it should return a string that contains the original `str` repeated `count` times.
 
-test("should repeat the string count times", () => {
+test("should repeat the string  3 times when  the value of count =3", () => {
   const str = "hello";
   const count = 3;
   const repeatedStr = repeatStr(str, count);
@@ -21,7 +21,7 @@ test("should repeat the string count times", () => {
 // When the repeatStr function is called with these inputs,
 // Then it should return the original `str` without repetition.
 
-test("should return the original `str` without repetition", () => {
+test("should return the original string when the count is 1", () => {
   const str = "hello";
   const count = 1;
   const repeatedStr = repeatStr(str, count);
@@ -33,7 +33,7 @@ test("should return the original `str` without repetition", () => {
 // When the repeatStr function is called with these inputs,
 // Then it should return an empty string.
 
-test("should return an empty string", () => {
+test("should return an empty string when the count is 0", () => {
   const str = "hello";
   const count = 0;
   const repeatedStr = repeatStr(str, count);
@@ -45,7 +45,7 @@ test("should return an empty string", () => {
 // When the repeatStr function is called with these inputs,
 // Then it should throw an error, as negative counts are not valid.
 
-test("should throw an error, as negative counts are not valid.", () => {
+test("should throw an error, when count is a negative number.", () => {
   const str = "hello";
   const count = -3;
   expect(() => repeatStr(str, count)).toThrow(

From 50817600fad00d25e4f0eb94c8142b7f743e7ce3 Mon Sep 17 00:00:00 2001
From: Abdennour Hachemi <tamokradz@gmail.com>
Date: Mon, 26 Oct 2026 22:24:25 +0000
Subject: [PATCH 19/19] running prettier to fromat the code

---
 practice-tdd/get-ordinal-number.js      |  3 ---
 practice-tdd/get-ordinal-number.test.js | 14 +++++---------
 2 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/practice-tdd/get-ordinal-number.js b/practice-tdd/get-ordinal-number.js
index 182679379..7ddd7fd01 100644
--- a/practice-tdd/get-ordinal-number.js
+++ b/practice-tdd/get-ordinal-number.js
@@ -3,14 +3,11 @@ export function getOrdinalNumber(num) {
   if (!num) {
     return "";
   }
-
   const lastTwoDigits = num % 100;
-
   // Handle exceptions: 11th, 12th, 13th, 111th, etc.
   if (lastTwoDigits >= 11 && lastTwoDigits <= 13) {
     return `${num}th`;
   }
-
   switch (num % 10) {
     case 1:
       return `${num}st`;
diff --git a/practice-tdd/get-ordinal-number.test.js b/practice-tdd/get-ordinal-number.test.js
index a9494ac93..97fa8c94c 100644
--- a/practice-tdd/get-ordinal-number.test.js
+++ b/practice-tdd/get-ordinal-number.test.js
@@ -1,17 +1,15 @@
 import { getOrdinalNumber } from "./get-ordinal-number.js";
 
 // In this week's prep, we started implementing getOrdinalNumber.
-
 // Continue testing and implementing getOrdinalNumber for additional cases.
 // Write your tests using Jest — remember to run your tests often for continual feedback.
-
 // To ensure thorough testing, we need broad scenarios that cover all possible cases.
 // Listing individual values, however, can quickly lead to an unmanageable number of test cases.
 // Instead of writing tests for individual numbers, consider grouping all possible input values
 // into meaningful categories. Then, select representative samples from each category to test.
 // This approach improves coverage and makes our tests easier to maintain.
 
-// Case 1: 
+// Case 1:
 test("should append 'st' for numbers ending with 1, except those ending with 11", () => {
   expect(getOrdinalNumber(1)).toEqual("1st");
   expect(getOrdinalNumber(21)).toEqual("21st");
@@ -31,12 +29,12 @@ test("should append 'nd' for numbers ending with 2, except those ending with 12"
 test("should append 'rd' for numbers ending with 3, except those ending with 13", () => {
   expect(getOrdinalNumber(3)).toEqual("3rd");
   expect(getOrdinalNumber(43)).toEqual("43rd");
-   expect(getOrdinalNumber(93)).toEqual("93rd");
+  expect(getOrdinalNumber(93)).toEqual("93rd");
   expect(getOrdinalNumber(823)).toEqual("823rd");
-   expect(getOrdinalNumber(183)).toEqual("183rd");
+  expect(getOrdinalNumber(183)).toEqual("183rd");
 });
 
-// Case 4: 
+// Case 4:
 test("should append 'th' for numbers ending with 4,5,6 ,7 ,8 or 9 ", () => {
   expect(getOrdinalNumber(4)).toEqual("4th");
   expect(getOrdinalNumber(25)).toEqual("25th");
@@ -46,7 +44,7 @@ test("should append 'th' for numbers ending with 4,5,6 ,7 ,8 or 9 ", () => {
   expect(getOrdinalNumber(34454559)).toEqual("34454559th");
 });
 
-// Case 5: 
+// Case 5:
 test("should append 'th' for numbers in 100's ending with 11, 12 , 13", () => {
   expect(getOrdinalNumber(111)).toEqual("111th");
   expect(getOrdinalNumber(112)).toEqual("112th");
@@ -63,8 +61,6 @@ test("should append 'th' for numbers for 11,12,13 and 'st' for 101 and 'rd' for
   expect(getOrdinalNumber(103)).toEqual("103rd");
 });
 
-
 test("should return empty string if empty string is passed", () => {
   expect(getOrdinalNumber("")).toEqual("");
- 
 });