sprint3 coursework done.

Author: eminakturk

Sprint-3/2-mandatory-rewrite/1-get-angle-type.js

@@ -1,6 +1,10 @@
 function getAngleType(angle) {
   if (angle === 90) return "Right angle";
-  // replace with your completed function from key-implement
+  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";
+}
 
 }
 

Sprint-3/2-mandatory-rewrite/1-get-angle-type.test.js

@@ -4,21 +4,25 @@ test("should identify right angle (90°)", () => {
   expect(getAngleType(90)).toEqual("Right angle");
 });
 
-// REPLACE the comments with the tests
-// make your test descriptions as clear and readable as possible
-
 // Case 2: Identify Acute Angles:
 // When the angle is less than 90 degrees,
 // Then the function should return "Acute angle"
+test("should identify acute angles (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 angles (greater than 90° and less than 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"
+/

Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.js

@@ -1,6 +1,11 @@
 function isProperFraction(numerator, denominator) {
     if (numerator < denominator) return true;
     // add your completed function from key-implement here
+    if (Math.abs(numerator) < Math.abs(denominator)) {
+        return true;
+    } else {
+        return false;
+    }
 }
 
-module.exports = isProperFraction;
+module.exports = isProperFraction;

Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.test.js

@@ -5,7 +5,16 @@ test("should return true for a proper fraction", () => {
 });
 
 // Case 2: Identify Improper Fractions:
+test("should return false for an improper fraction", () => {
+  expect(isProperFraction(5, 2)).toEqual(false);
+});
 
 // Case 3: Identify Negative Fractions:
+test("should return true for a negative proper fraction", () => {
+  expect(isProperFraction(-4, 7)).toEqual(true);
+});
 
 // Case 4: Identify Equal Numerator and Denominator:
+test("should return false when numerator and denominator are equal", () => {
+  expect(isProperFraction(3, 3)).toEqual(false);
+});

Sprint-3/2-mandatory-rewrite/3-get-card-value.js

@@ -1,5 +1,9 @@
 function getCardValue(card) {
-    // replace with your code from key-implement
-    return 11;
+    const rank = card.slice(0, -1);
+    if (rank === "A") return 11;
+    if (rank === "J" || rank === "Q" || rank === "K" || rank === "10") return 10;
+    if (!isNaN(rank)) return Number(rank);
+    throw new Error("Invalid card rank.");
 }
-module.exports = getCardValue;
+
+module.exports = getCardValue;

Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js

@@ -3,9 +3,26 @@ const getCardValue = require("./3-get-card-value");
 test("should return 11 for Ace of Spades", () => {
     const aceofSpades = getCardValue("A♠");
     expect(aceofSpades).toEqual(11);
-    });
+});
 
 // Case 2: Handle Number Cards (2-10):
+test("should return correct number for number cards", () => {
+    expect(getCardValue("5♥")).toEqual(5);
+    expect(getCardValue("10♦")).toEqual(10);
+});
+
 // Case 3: Handle Face Cards (J, Q, K):
+test("should return 10 for face cards J, Q, K", () => {
+    expect(getCardValue("J♣")).toEqual(10);
+    expect(getCardValue("Q♦")).toEqual(10);
+    expect(getCardValue("K♥")).toEqual(10);
+});
+
 // Case 4: Handle Ace (A):
+// (Already tested above with Ace of Spades)
+
 // Case 5: Handle Invalid Cards:
+test("should throw error for invalid cards", () => {
+    expect(() => getCardValue("Z♠")).toThrow("Invalid card rank.");
+    expect(() => getCardValue("1♠")).toThrow("Invalid card rank.");
+});

Sprint-3/3-mandatory-practice/implement/count.js

@@ -1,5 +1,9 @@
 function countChar(stringOfCharacters, findCharacter) {
-    return 5
+    let count = 0;
+    for (let char of stringOfCharacters) {
+        if (char === findCharacter) count++;
+    }
+    return count;
 }
 
-module.exports = countChar;
+module.exports = countChar;

Sprint-3/3-mandatory-practice/implement/count.test.js

@@ -1,5 +1,5 @@
-// implement a function countChar that counts the number of times a character occurs in a string
 const countChar = require("./count");
+
 // 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 +22,10 @@ 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 return 0 if character does not occur", () => {
+  const str = "Hello World";
+  const char = "z";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});

Sprint-3/3-mandatory-practice/implement/get-ordinal-number.js

@@ -1,5 +1,12 @@
 function getOrdinalNumber(num) {
- return "1st";
+  const suffixes = ["th", "st", "nd", "rd"];
+  const v = num % 100;
+  if (v >= 11 && v <= 13) {
+    return num + "th";
+  } else {
+    const suffix = suffixes[(num % 10)] || "th";
+    return num + suffix;
+  }
 }
 
-module.exports = getOrdinalNumber;
+module.exports = getOrdinalNumber;

Sprint-3/3-mandatory-practice/implement/get-ordinal-number.test.js

@@ -10,4 +10,4 @@ const getOrdinalNumber = require("./get-ordinal-number");
 
 test("should return '1st' for 1", () => {
     expect(getOrdinalNumber(1)).toEqual("1st");
-    });
+});