From 8b901a43c5c2aecffe6e337863c4d7b9b5d9fe03 Mon Sep 17 00:00:00 2001 From: Xinxi Date: Sun, 21 Dec 2025 10:55:47 +0100 Subject: [PATCH 1/3] impletment completed --- .../implement/1-get-angle-type.js | 22 ++++++++++++++++--- .../implement/2-is-proper-fraction.js | 14 ++++++++++-- .../implement/3-get-card-value.js | 19 +++++++++++++--- 3 files changed, 47 insertions(+), 8 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..0085ad61b 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 @@ -11,9 +11,21 @@ function getAngleType(angle) { if (angle === 90) { return "Right angle"; } + if (angle < 90) { + return "Acute angle"; + } + if (angle > 90 && angle < 180) { + return "Obtuse angle"; + } + if (angle === 180) { + return "Straight angle"; + } + if (angle > 180 && angle < 360) { + return "Reflex 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. @@ -50,14 +62,18 @@ 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 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 +// ====> write your test here, and then add a line to pass the test in the function above +const reflex = getAngleType(200); +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..db1a839ef 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,10 @@ // write one test at a time, and make it pass, build your solution up methodically function isProperFraction(numerator, denominator) { - if (numerator < denominator) { + if (Math.abs(numerator) < denominator) { return true; + } else { + return false; } } @@ -47,6 +49,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 @@ -54,6 +57,13 @@ 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 and Denominator check: +// Input: numerator = 0, denominator = 5 +// target output: true +// Explanation: Numerator is smaller than denominator. +const zeroFraction = isProperFraction(0, 5); +assertEquals(zeroFraction, true); \ 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 266525d1b..5c5087b5a 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,18 @@ // 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) { + const rank = card.slice(0, -1); if (rank === "A") { return 11; } + if (rank === "10" || rank === "J" || rank === "K" || rank === "Q") { + return 10; + } + const numberRank = parseInt(rank); + if (!isNaN(numberRank) && numberRank >= 2 && numberRank <= 9) { + return numberRank; + } + else return "Invalid card rank."; } // The line below allows us to load the getCardValue function into tests in other files. @@ -40,18 +49,22 @@ 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); // 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); // 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 aceofHearts = getCardValue("A♥"); +assertEquals(aceofHearts, 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." +const errorTothrow = getCardValue("20♥"); +assertEquals(errorTothrow, "Invalid card rank."); \ No newline at end of file From 0fbe9dc624751b012a0c5d2ed28690bf671bdc0c Mon Sep 17 00:00:00 2001 From: Xinxi Date: Sun, 21 Dec 2025 12:19:05 +0100 Subject: [PATCH 2/3] rewrite-test-with-jest completed --- .../1-get-angle-type.test.js | 15 ++++++++++++--- .../2-is-proper-fraction.test.js | 11 +++++++++-- .../3-get-card-value.test.js | 16 ++++++++++++++++ 3 files changed, 37 insertions(+), 5 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 4a92a3e82..7aa11a00b 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,24 @@ 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 (e.g., 45°) which are less than 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 (e.g., 120°) which are between 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 straight angle (e.g., 200°) which are between 180° and 360°;", () => { + expect(getAngleType(200)).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..68a6ba413 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,14 @@ test("should return true for a proper fraction", () => { }); // Case 2: Identify Improper Fractions: - +test("should return true for an improper fraction", () => { + expect(isProperFraction(5, 2)).toEqual(false); +}); // Case 3: Identify Negative Fractions: - +test("should return true for a negative fraction", () => { + expect(isProperFraction(-4, 7)).toEqual(true); +}); // Case 4: Identify Equal Numerator and Denominator: +test("should return true for a proper 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 04418ff72..93dc4622c 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,22 @@ test("should return 11 for Ace of Spades", () => { }); // Case 2: Handle Number Cards (2-10): + test("should return 5 for Five of Hearts", () => { + const fiveofHearts = getCardValue("5♥"); + expect(fiveofHearts).toEqual(5); + }); // Case 3: Handle Face Cards (J, Q, K): + test("should return 10 for J of Diamonds", () => { + const jofDiamonds = getCardValue("J♦"); + expect(jofDiamonds).toEqual(10); + }); // Case 4: Handle Ace (A): +test("should return 11 for Ace of Hearts", () => { + const aceofHearts = getCardValue("A♥"); + expect(aceofHearts).toEqual(11); + }); // Case 5: Handle Invalid Cards: +test("should return Invalid card rank. for twenty of Hearts", () => { + const twentyofHearts = getCardValue("20♥"); + expect(twentyofHearts).toEqual("Invalid card rank."); + }); \ No newline at end of file From e7ff019f7b22530603b59eb33da2c94fea0dd9f8 Mon Sep 17 00:00:00 2001 From: Xinxi Date: Mon, 22 Dec 2025 12:04:40 +0100 Subject: [PATCH 3/3] 2-practice-tdd completed --- Sprint-3/2-practice-tdd/count.js | 8 +++++++- Sprint-3/2-practice-tdd/count.test.js | 6 ++++++ Sprint-3/2-practice-tdd/get-ordinal-number.js | 11 ++++++++++- .../2-practice-tdd/get-ordinal-number.test.js | 8 ++++++++ Sprint-3/2-practice-tdd/repeat-str.js | 14 +++++++++++--- Sprint-3/2-practice-tdd/repeat-str.test.js | 19 +++++++++++++++++-- 6 files changed, 59 insertions(+), 7 deletions(-) diff --git a/Sprint-3/2-practice-tdd/count.js b/Sprint-3/2-practice-tdd/count.js index 95b6ebb7d..d59e425d6 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 count = 0; + for (let i = 0; i < stringOfCharacters.length; i++) { + if (stringOfCharacters[i] === findCharacter) { + count++; + } + } + return count; } module.exports = countChar; diff --git a/Sprint-3/2-practice-tdd/count.test.js b/Sprint-3/2-practice-tdd/count.test.js index 42baf4b4b..4ad361668 100644 --- a/Sprint-3/2-practice-tdd/count.test.js +++ b/Sprint-3/2-practice-tdd/count.test.js @@ -22,3 +22,9 @@ 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 count as 0 while a character char does not exist in a str", () => { + const str = "Hello World!"; + const char = "x"; + const count = countChar(str, char); + expect(count).toEqual(0); +}); \ No newline at end of file diff --git a/Sprint-3/2-practice-tdd/get-ordinal-number.js b/Sprint-3/2-practice-tdd/get-ordinal-number.js index f95d71db1..e43ce7988 100644 --- a/Sprint-3/2-practice-tdd/get-ordinal-number.js +++ b/Sprint-3/2-practice-tdd/get-ordinal-number.js @@ -1,5 +1,14 @@ function getOrdinalNumber(num) { - return "1st"; + if (num === 1) { + return "1st"; + } + if (num === 2) { + return "2nd"; + } + if(num === 3) { + return "3rd"; + } + return 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 dfe4b6091..15ffb6b36 100644 --- a/Sprint-3/2-practice-tdd/get-ordinal-number.test.js +++ b/Sprint-3/2-practice-tdd/get-ordinal-number.test.js @@ -11,3 +11,11 @@ const getOrdinalNumber = require("./get-ordinal-number"); test("should return '1st' for 1", () => { expect(getOrdinalNumber(1)).toEqual("1st"); }); + +test("should return '11th' for 11", () => { + expect(getOrdinalNumber(11)).toEqual("11th"); +}); + +test("should return '12th' for 12", () => { + expect(getOrdinalNumber(12)).toEqual("12th"); +}); \ No newline at end of file diff --git a/Sprint-3/2-practice-tdd/repeat-str.js b/Sprint-3/2-practice-tdd/repeat-str.js index 3838c7b00..36a222ec3 100644 --- a/Sprint-3/2-practice-tdd/repeat-str.js +++ b/Sprint-3/2-practice-tdd/repeat-str.js @@ -1,5 +1,13 @@ -function repeatStr() { - return "hellohellohello"; +function repeatStr(str, count) { + if (count < 0) { + throw new Error("Count must be a non-negative integer."); + } + if (count === 0) { + return ""; + } + if (count === 1) { + return str; + } + 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 fc59d019e..51ef88ec1 100644 --- a/Sprint-3/2-practice-tdd/repeat-str.test.js +++ b/Sprint-3/2-practice-tdd/repeat-str.test.js @@ -20,13 +20,28 @@ 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, ensuring that a count of 1 results in no 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, ensuring that a count of 0 results in an empty output. - +test("should return an empty string", () => { + const str = "hello"; + const count = 0; + const repeatedStr = repeatStr(str, count); + expect(repeatedStr).toEqual(""); +}); // case: 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 or return an appropriate error message, as negative counts are not valid. +test("should an appropriate error message", () => { + const str = "hello"; + const count = -5; + expect(() => repeatedStr(str, count)).toThrow(Error); +}); \ No newline at end of file