Barcelona | Oct2025-2 | Roman Pavlenko | Sprint-3 | Coursework

Sprint-3/1-key-implement/1-get-angle-type.js

@@ -7,10 +7,15 @@
 // 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";
-   // read to the end, complete line 36, then pass your test here
-}
+  function getAngleType(angle) {
+    if (angle < 90) return "Acute angle";
+    else if (angle === 90) return "Right 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 if (angle === 360) return "Full rotation";
+  }
+  module.exports = { getAngleType };
 
 // we're going to use this helper function to make our assertions easier to read
 // if the actual output matches the target output, the test will pass
@@ -42,15 +47,26 @@ assertEquals(acute, "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"
-const obtuse = getAngleType(120);
 // ====> write your test here, and then add a line to pass the test in the function above
+const obtuse = getAngleType(120);
+assertEquals(obtuse, "Obtuse angle");
 
 // 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
+// ====> 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");
+ // Case 6: Identify Full Rotation:
+// When the angle is exactly 360 degrees,
+// Then the function should return "Full rotation"
+// ====> write your test here, and then add a line to pass the test in the function above
+  const fullRotation = getAngleType(360);
+  assertEquals(fullRotation, "Full rotation");

Sprint-3/1-key-implement/1-get-angle-type.test.js

@@ -0,0 +1,27 @@
+const { getAngleType } = require("./1-get-angle-type");
+
+describe("getAngleType", () => {
+  test("Case 1: identifies Right Angles", () => {
+    expect(getAngleType(90)).toBe("Right angle");
+  });
+
+  test("Case 2: identifies Acute Angles", () => {
+    expect(getAngleType(45)).toBe("Acute angle");
+  });
+
+  test("Case 3: identifies Obtuse Angles", () => {
+    expect(getAngleType(120)).toBe("Obtuse angle");
+  });
+
+  test("Case 4: identifies Straight Angles", () => {
+    expect(getAngleType(180)).toBe("Straight angle");
+  });
+
+  test("Case 5: identifies Reflex Angles", () => {
+    expect(getAngleType(270)).toBe("Reflex angle");
+  });
+
+  test("Case 6: identifies Full Rotation", () => {
+    expect(getAngleType(360)).toBe("Full rotation");
+  });
+}); 

Sprint-3/1-key-implement/2-is-proper-fraction.js

@@ -8,8 +8,16 @@
 // 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 < 0 && denominator < 0) {
+    numerator = -numerator;
+    denominator = -denominator;
+  }
+  if (denominator <= 0) return false;
+  if (numerator < denominator) return true;
+  else return false;
 }
+module.exports = { isProperFraction };
+
 
 // here's our helper again
 function assertEquals(actualOutput, targetOutput) {
@@ -51,3 +59,17 @@ const equalFraction = isProperFraction(3, 3);
 
 // Stretch:
 // What other scenarios could you test for?
+const stretchFraction1 = isProperFraction(0, 5);
+
+const stretchFraction2 = isProperFraction(3, -4);
+
+const stretchFraction3 = isProperFraction(-2, -3);
+// ====> complete with your assertions
+assertEquals(negativeFraction, true);
+assertEquals(equalFraction, false);
+assertEquals(stretchFraction1, true);
+assertEquals(stretchFraction2, false);
+assertEquals(stretchFraction3, true);
+const stretchFraction4 = isProperFraction(3, 0);
+assertEquals(stretchFraction4, false);
+

Sprint-3/1-key-implement/2-is-proper-fraction.test.js

@@ -0,0 +1,31 @@
+const { isProperFraction } = require("./2-is-proper-fraction");
+
+describe("isProperFraction", () => {
+  test("Case 1: identifies proper fractions", () => {
+    expect(isProperFraction(2, 3)).toBe(true);
+  });
+    test("Case 2: identifies improper fractions", () => {
+        expect(isProperFraction(5, 2)).toBe(false);
+    });
+    test("Case 3: identifies negative proper fractions", () => {
+        expect(isProperFraction(-4, 7)).toBe(true);
+    });
+    test("Case 4: identifies equal numerator and denominator as improper", () => {
+        expect(isProperFraction(3, 3)).toBe(false);
+    });
+    // Stretch tests can be added here
+    test("Stretch Case 1: identifies zero numerator as proper fraction", () => {
+        expect(isProperFraction(0, 5)).toBe(true);
+    });
+    test("Stretch Case 2: identifies negative denominator as improper fraction", () => {
+        expect(isProperFraction(3, -4)).toBe(false);
+    });
+    test("Stretch Case 3: identifies both negative numerator and denominator as proper fraction", () => {
+        expect(isProperFraction(-2, -3)).toBe(true);
+    });
+    test("Stretch Case 4: identifies zero denominator as improper fraction", () => {
+        expect(isProperFraction(3, 0)).toBe(false);
+    });
+
+});
+

Sprint-3/1-key-implement/3-get-card-value.js

@@ -7,10 +7,15 @@
 // complete the rest of the tests and cases
 // 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;
-}
+  if (card.charAt(0) === "A") return 11;
+  else if ((card.charAt(0) === "K") || (card.charAt(0) === "Q") || (card.charAt(0) === "J") || (card.slice(0, 2) === "10")) return 10;
+  else if (parseInt(card.charAt(0)) >= 2 && parseInt(card.charAt(0)) <= 9) return parseInt(card.charAt(0));
+  else throw new Error("Invalid card rank.");
 
+}
+module.exports = { getCardValue };
 // You need to write assertions for your function to check it works in different cases
 // we're going to use this helper function to make our assertions easier to read
 // if the actual output matches the target output, the test will pass
@@ -33,13 +38,21 @@ 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):
 // 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 kingofDiamonds = getCardValue("K♦");
+const queenofClubs = getCardValue("Q♣");
+const jackofSpades = getCardValue("J♠");
+const tenofHearts = getCardValue("10♥");
+assertEquals(kingofDiamonds, 10);
+assertEquals(queenofClubs, 10);
+assertEquals(jackofSpades, 10);
+assertEquals(tenofHearts, 10);
 // Handle Ace (A):
 // Given a card with a rank of "A",
 // When the function is called with an Ace,

Sprint-3/1-key-implement/3-get-card-value.test.js

@@ -0,0 +1,27 @@
+const {getCardValue} = require("./3-get-card-value");
+
+describe("getCardValue", () => {
+    test("Case 1: handles Ace (A)", () => {
+        expect(getCardValue("A♠")).toBe(11);
+    });
+    test("Case 2: handles Number Cards (2-10)", () => {
+        expect(getCardValue("5♥")).toBe(5);
+    });
+    test("Case 3: handles Face Cards (J, Q, K)", () => {
+        expect(getCardValue("K♦")).toBe(10);
+        expect(getCardValue("Q♣")).toBe(10);
+        expect(getCardValue("J♠")).toBe(10);
+        expect(getCardValue("10♥")).toBe(10);
+    });
+    test("Stretch Case: handles Invalid Cards", () => {
+        expect(() => {
+            getCardValue("1♠");
+        }).toThrow("Invalid card rank.");
+    });
+    test("Stretch Case: handles Invalid Cards with letter", () => {
+        expect(() => {
+            getCardValue("X♠");
+        }).toThrow("Invalid card rank.");
+    });
+
+});