From 73a15008023edbc1b26df1bdf3f120605c74d764 Mon Sep 17 00:00:00 2001 From: Raihan Sharif Date: Wed, 25 Feb 2026 14:51:50 +0000 Subject: [PATCH] tdd assignment --- Sprint-3/2-practice-tdd/count.js | 8 +++- Sprint-3/2-practice-tdd/count.test.js | 18 +++++++++ Sprint-3/2-practice-tdd/get-ordinal-number.js | 16 +++++++- .../2-practice-tdd/get-ordinal-number.test.js | 38 +++++++++++++++++++ Sprint-3/2-practice-tdd/repeat-str.js | 14 ++++++- Sprint-3/2-practice-tdd/repeat-str.test.js | 20 +++++++++- 6 files changed, 108 insertions(+), 6 deletions(-) diff --git a/Sprint-3/2-practice-tdd/count.js b/Sprint-3/2-practice-tdd/count.js index 95b6ebb7d..c39faabe2 100644 --- a/Sprint-3/2-practice-tdd/count.js +++ b/Sprint-3/2-practice-tdd/count.js @@ -1,5 +1,11 @@ function countChar(stringOfCharacters, findCharacter) { - return 5 + let total = 0; + for (const char of stringOfCharacters) { + if (char === findCharacter) { + total += 1; + } + } + return total; } module.exports = countChar; diff --git a/Sprint-3/2-practice-tdd/count.test.js b/Sprint-3/2-practice-tdd/count.test.js index 179ea0ddf..2b8e28ae3 100644 --- a/Sprint-3/2-practice-tdd/count.test.js +++ b/Sprint-3/2-practice-tdd/count.test.js @@ -22,3 +22,21 @@ 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 count zero occurrences of a character", () => { + const str = "aaaaa"; + const char = "b"; + const count = countChar(str, char); + expect(count).toEqual(0); +}); + +// Scenario: Non-consecutive occurrances +// Given the input string `str`, +// And a character `char` that appears in more than one block within `str`. +// When the function is called with these inputs, +// Then it should return the number of total occurrances. +test("should count non-contiguous occurrences of a character", () => { + const str = "aaaaabba"; + const char = "a"; + const count = countChar(str, char); + expect(count).toEqual(6); +}); diff --git a/Sprint-3/2-practice-tdd/get-ordinal-number.js b/Sprint-3/2-practice-tdd/get-ordinal-number.js index f95d71db1..378f4b832 100644 --- a/Sprint-3/2-practice-tdd/get-ordinal-number.js +++ b/Sprint-3/2-practice-tdd/get-ordinal-number.js @@ -1,5 +1,19 @@ function getOrdinalNumber(num) { - return "1st"; + // 11 is a special case + if (num === 11) { + return "11th"; + } + const lastDigit = num % 10; + switch (lastDigit) { + case 1: + return String(num) + "st"; + case 2: + return String(num) + "nd"; + case 3: + return String(num) + "rd"; + default: + return String(num) + "th"; + } } module.exports = getOrdinalNumber; diff --git a/Sprint-3/2-practice-tdd/get-ordinal-number.test.js b/Sprint-3/2-practice-tdd/get-ordinal-number.test.js index adfa58560..08136cb0f 100644 --- a/Sprint-3/2-practice-tdd/get-ordinal-number.test.js +++ b/Sprint-3/2-practice-tdd/get-ordinal-number.test.js @@ -18,3 +18,41 @@ 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 +// When the number ends with 2 +// Then the function should return a string by appending "nd" to the number. +test("should append 'nd' for numbers ending with 2", () => { + expect(getOrdinalNumber(2)).toEqual("2nd"); + expect(getOrdinalNumber(22)).toEqual("22nd"); + expect(getOrdinalNumber(132)).toEqual("132nd"); +}); + +// Case 3: Numbers ending with 3 +// When the number ends with 3 +// Then the function should return a string by appending "rd" to the number. +test("should append 'rd' for numbers ending with 3", () => { + expect(getOrdinalNumber(3)).toEqual("3rd"); + expect(getOrdinalNumber(23)).toEqual("23rd"); + expect(getOrdinalNumber(223)).toEqual("223rd"); +}); + +// Case 4: the general(ish) case +// When numbers end with 0, 4, 5, 6, 7, 8, 9 +// The function should return a string by appending "th" to the number +test("should append 'th' for numbers ending with 0, 4, 5, 6, 7, 8, 9", () => { + expect(getOrdinalNumber(10)).toEqual("10th"); + expect(getOrdinalNumber(24)).toEqual("24th"); + expect(getOrdinalNumber(25)).toEqual("25th"); + expect(getOrdinalNumber(46)).toEqual("46th"); + expect(getOrdinalNumber(57)).toEqual("57th"); + expect(getOrdinalNumber(78)).toEqual("78th"); + expect(getOrdinalNumber(89)).toEqual("89th"); +}); + +// Case 5: The special case of 11 +// When the number is 11 +// Then the function should return a string by appending "th" to the number. +test("should append 'th' for 11", () => { + expect(getOrdinalNumber(11)).toEqual("11th"); +}); diff --git a/Sprint-3/2-practice-tdd/repeat-str.js b/Sprint-3/2-practice-tdd/repeat-str.js index 3838c7b00..e0b07d014 100644 --- a/Sprint-3/2-practice-tdd/repeat-str.js +++ b/Sprint-3/2-practice-tdd/repeat-str.js @@ -1,5 +1,15 @@ -function repeatStr() { - return "hellohellohello"; +function repeatStr(str, count) { + if (count < 0) { + throw new Error("invalid input: negative number"); + } + + if (count === 0) { + return ""; + } + + if ((count) => 1) { + return str.repeat(count); + } } module.exports = repeatStr; diff --git a/Sprint-3/2-practice-tdd/repeat-str.test.js b/Sprint-3/2-practice-tdd/repeat-str.test.js index a3fc1196c..8f818ad74 100644 --- a/Sprint-3/2-practice-tdd/repeat-str.test.js +++ b/Sprint-3/2-practice-tdd/repeat-str.test.js @@ -8,8 +8,7 @@ const repeatStr = require("./repeat-str"); // Given a target string `str` and a positive integer `count` greater than 1, // 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", () => { const str = "hello"; const count = 3; const repeatedStr = repeatStr(str, count); @@ -20,13 +19,30 @@ test("should repeat the string count times", () => { // Given a target string `str` and a `count` equal to 1, // When the repeatStr function is called with these inputs, // Then it should return the original `str` without repetition. +test("should not repeat string with a count of 1", () => { + 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 empty string with a count of 0", () => { + 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 error when count < 0", () => { + const str = "hello"; + const count = -2; + expect(() => repeatStr(str, count)).toThrow(); +});