From f34d033cefe99fa2bbd6e213f5b7636f21af8405 Mon Sep 17 00:00:00 2001 From: Della Bella Date: Tue, 14 Oct 2025 21:33:08 +0100 Subject: [PATCH 1/7] Practice Writing tests --- .../implement/1-get-angle-type.js | 23 +++++++++++++++---- 1 file changed, 18 insertions(+), 5 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..948cd5485 100644 --- a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js +++ b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js @@ -8,12 +8,22 @@ // Then, write the next test! :) Go through this process until all the cases are implemented function getAngleType(angle) { - if (angle === 90) { + if (angle === 90) { return "Right angle"; + } else if (angle < 90) { + return "Acute angle"; + } else if (angle > 90 && angle < 180) { + return "Obtuse angle"; + } else if (angle === 180) { + return "Straight angle"; + } else if (angle > 180 && angle < 360) { + return "Reflex angle"; + } else { + return "Invalid angle"; } +} // Run the tests, work out what Case 2 is testing, and implement the required code here. // Then keep going for the other cases, one at a time. -} // 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 +60,17 @@ assertEquals(acute, "Acute angle"); // When the angle is greater than 90 degrees and less than 180 degrees, // Then the function should return "Obtuse angle" const obtuse = getAngleType(120); -// ====> write your test here, and then add a line to pass the test in the function above +assertEquals( obtuse, "Obtuse angle") // Case 4: Identify Straight Angles: // When the angle is exactly 180 degrees, +const straight = getAngleType(180) +assertEquals (straight, "Straight angle"); // Then the function should return "Straight angle" -// ====> write your test here, and then add a line to pass the test in the function above + // Case 5: Identify Reflex Angles: // When the angle is greater than 180 degrees and less than 360 degrees, // Then the function should return "Reflex angle" -// ====> write your test here, and then add a line to pass the test in the function above \ No newline at end of file +const reflex= getAngleType( 350); +assertEquals (reflex, "Reflex angle"); \ No newline at end of file From fcd184f6cef5a3e814a9d9f31507b08103d0321a Mon Sep 17 00:00:00 2001 From: Della Bella Date: Tue, 14 Oct 2025 22:26:18 +0100 Subject: [PATCH 2/7] practicing asserting tests --- .../implement/2-is-proper-fraction.js | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js index a4739af77..b0c73145d 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 @@ -9,7 +9,10 @@ function isProperFraction(numerator, denominator) { if (numerator < denominator) { - return true; + return true ; + } + else { + return false; } } @@ -38,14 +41,15 @@ assertEquals(properFraction, true); // Input: numerator = 5, denominator = 2 // target output: false // Explanation: The fraction 5/2 is an improper fraction, where the numerator is greater than or equal to the denominator. The function should return false. -const improperFraction = isProperFraction(5, 2); -assertEquals(improperFraction, false); +const properFraction2 = isProperFraction(5, 2); +assertEquals(properFraction2, false); // Negative Fraction check: // Input: numerator = -4, denominator = 7 // target output: true // Explanation: The fraction -4/7 is a proper fraction because the absolute value of the numerator (4) is less than the denominator (7). The function should return true. const negativeFraction = isProperFraction(-4, 7); +assertEquals(negativeFraction, true); // ====> complete with your assertion // Equal Numerator and Denominator check: @@ -53,7 +57,13 @@ const negativeFraction = isProperFraction(-4, 7); // target output: false // Explanation: The fraction 3/3 is not a proper fraction because the numerator is equal to the denominator. The function should return false. const equalFraction = isProperFraction(3, 3); -// ====> complete with your assertion +assertEquals(equalFraction, false); // Stretch: // What other scenarios could you test for? + +const properFraction3 = isProperFraction(0, 6); +assertEquals(properFraction3,true) + +const properFraction4 = isProperFraction(0, 1); +assertEquals(properFraction4, true); From 03256d2d3e609ff29f1f1550b87ed3f2927a745f Mon Sep 17 00:00:00 2001 From: Della Bella Date: Fri, 17 Oct 2025 21:24:09 +0100 Subject: [PATCH 3/7] Practice Testing Angles --- .../1-get-angle-type.test.js | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js index 4a92a3e82..972a06684 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,34 @@ 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" +//else if (angle < 90) { +//return "Acute angle"; + +test("returns Acute angle for values less than 90 degrees",() =>{ + 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("returns Obtuse angle for values greater than 90 degrees and less than 180 degrees",()=>{ + 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("returns Straight angle for 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("returns Reflex angle for angles > 180 && angle < 360",() =>{ +expect(getAngleType(290)).toEqual("Reflex angle"); +}); \ No newline at end of file From 3e16cd7c4687736f18d260caa805683b4455c0e8 Mon Sep 17 00:00:00 2001 From: Della Bella Date: Fri, 17 Oct 2025 21:38:39 +0100 Subject: [PATCH 4/7] Function Numerator & Denominator Tests --- .../2-is-proper-fraction.test.js | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) 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..7601892e4 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 @@ -8,6 +8,28 @@ test("should return true for a proper fraction", () => { // Case 2: Identify Improper Fractions: +test("it is a Improper Fraction",() =>{ + expect(isProperFraction(3, 2)).toEqual(false); +}); + // Case 3: Identify Negative Fractions: +test("it is a Negative Fraction",() =>{ + expect(isProperFraction(-2, 6)).toEqual(true); +}); // Case 4: Identify Equal Numerator and Denominator: + +test("It is a equal numerator and denominador", () =>{ + expect(isProperFraction( 2, 2)).toEqual(false); +}); + + + +// function isProperFraction(numerator, denominator) { +// if (numerator < denominator) { +// return true ; +// } +// else { +// return false; +// } +// } \ No newline at end of file From ba395e176b77e719b154c34a3e611573300f9d09 Mon Sep 17 00:00:00 2001 From: Della Bella Date: Fri, 17 Oct 2025 22:25:08 +0100 Subject: [PATCH 5/7] Function/ Tests Cards --- .../implement/3-get-card-value.js | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) 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..aa374b4b4 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,8 +8,15 @@ // write one test at a time, and make it pass, build your solution up methodically // just make one change at a time -- don't rush -- programmers are deep and careful thinkers function getCardValue(card) { + let rank = card.substring(0, card.length - 1); if (rank === "A") { return 11; + } else if (rank === "J" || rank === "Q" || rank === "K" || rank === "10") { + return 10; + } else if (rank >= "2" && rank <= "9") { + return parseInt(rank); + } else { + throw new Error("Invalid card rank."); } } @@ -39,6 +46,7 @@ assertEquals(aceofSpades, 11); // When the function is called with such a card, // Then it should return the numeric value corresponding to the rank (e.g., "5" should return 5). const fiveofHearts = getCardValue("5♥"); +assertEquals(fiveofHearts, 5); // ====> write your test here, and then add a line to pass the test in the function above // Handle Face Cards (J, Q, K): @@ -46,12 +54,22 @@ const fiveofHearts = getCardValue("5♥"); // 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 tenOfSpades = getCardValue("10♠"); +assertEquals(tenOfSpades, 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(aceofSpades, 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 invalidCard = getCardValue("87"); +assertEquals(invalidCard, "Invalid card rank"); \ No newline at end of file From 3a4df3a280e1c4e8367e99aa241f266e4436e095 Mon Sep 17 00:00:00 2001 From: Della Bella Date: Fri, 17 Oct 2025 22:40:52 +0100 Subject: [PATCH 6/7] Cards Tests --- .../3-get-card-value.test.js | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) 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..4ff21d21b 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,24 @@ test("should return 11 for Ace of Spades", () => { }); // Case 2: Handle Number Cards (2-10): + +test("should return number cards", () => { +const fiveofHearts = getCardValue("5♥"); +expect(fiveofHearts).toEqual(5); +}); + // Case 3: Handle Face Cards (J, Q, K): +test ("should return Face Cards J, Q, K ", () =>{ + const jackOfClubs = getCardValue("J♣"); + expect(jackOfClubs).toEqual(10); +}); + // Case 4: Handle Ace (A): +test ("should return Ace", () =>{ +const aceofHearts = getCardValue("A♥"); + expect(aceofHearts).toEqual(11); +}); // Case 5: Handle Invalid Cards: +test("should throw 'Invalid card rank' for a rank of '1'", () => { + expect(() => getCardValue("1♦")).toThrow("Invalid card rank."); +}); \ No newline at end of file From eb16d4fd4eb417bae545b62319c05f842d25ae78 Mon Sep 17 00:00:00 2001 From: Della Bella Date: Sun, 16 Nov 2025 11:11:42 +0000 Subject: [PATCH 7/7] Refractore the code to erase the redudance on the if and else. --- .../implement/1-get-angle-type.js | 36 ++++++++++++++----- 1 file changed, 27 insertions(+), 9 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 948cd5485..94dffaa9d 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 @@ -7,21 +7,39 @@ // Write the code to pass the test // Then, write the next test! :) Go through this process until all the cases are implemented +// function getAngleType(angle) { +// if (angle === 90) { +// return "Right angle"; +// } else if (angle < 90) { +// return "Acute angle"; +// } else if (angle > 90 && angle < 180) { +// return "Obtuse angle"; +// } else if (angle === 180) { +// return "Straight angle"; +// } else if (angle > 180 && angle < 360) { +// return "Reflex angle"; +// } else { +// return "Invalid angle"; +// } +// } + function getAngleType(angle) { - if (angle === 90) { - return "Right angle"; - } else if (angle < 90) { + // Start with the smallest angles or specific exact values first for clarity + + if (angle < 0 || angle >= 360) { // Check for invalid angles outside the 0 to <360 range first + return "Invalid angle"; + } else if (angle < 90) { // If it's not invalid, and it's less than 90 return "Acute angle"; - } else if (angle > 90 && angle < 180) { + } else if (angle === 90) { // If it's not less than 90, and it's exactly 90 + return "Right angle"; + } else if (angle < 180) { // If it's not <90, not ===90, then it must be >90. So only need to check <180 return "Obtuse angle"; - } else if (angle === 180) { + } else if (angle === 180) { // If it's not <180, and it's exactly 180 return "Straight angle"; - } else if (angle > 180 && angle < 360) { + } else if (angle < 360) { // If it's not <180, not ===180, then it must be >180. So only need to check <360 return "Reflex angle"; - } else { - return "Invalid angle"; } -} +}; // Run the tests, work out what Case 2 is testing, and implement the required code here. // Then keep going for the other cases, one at a time.