Manchester | 26-ITP-Sept | Aklilu Mihtsun | Sprint 2 | Implement and rewrite tests

implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js

@@ -10,3 +10,17 @@ test("Classifies right angles", () => {
   const right = getAngleType(90);
   assert.equal(right, "Right angle");
 });
+test("Classifies acute angles", () =>
+  assert.equal(getAngleType(89), "Acute angle"));
+test("Classifies obtuse angle", () =>
+  assert.equal(getAngleType(130), "Obtuse angle"));
+test("Classifies straight angle", () =>
+  assert.equal(getAngleType(180), "Straight angle"));
+test("Classifies reflex angle", () =>
+  assert.equal(getAngleType(240), "Reflex angle"));
+test("Classifies invalid angle range", () => {
+  assert.equal(getAngleType(450), "Invalid angle");
+  assert.equal(getAngleType(0), "Invalid angle");
+  assert.equal(getAngleType(360), "Invalid angle");
+  assert.equal(getAngleType(-120), "Invalid angle");
+});

implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js

@@ -8,5 +8,19 @@ import { isProperFraction } from "../implement/2-is-proper-fraction.js";
 
 test("Basic proper fraction", () => {
   // Example: 1/2 is a proper fraction
-  assert.equal(isProperFraction(1, 2), true);
+  assert.equal(isProperFraction(1, -2), true);
+  assert.equal(isProperFraction(-3, 5), true);
+  assert.equal(isProperFraction(0.5, 0.7), true);
+});
+test("Basic improper fraction", () => {
+  assert.equal(isProperFraction(5, 3), false);
+  assert.equal(isProperFraction(7, -3), false);
+  assert.equal(isProperFraction(-8, 6), false);
+});
+test("When numerator and denominator are equal", function () {
+  assert.equal(isProperFraction(7, 7), false);
+  assert.equal(isProperFraction(-2, -2), false);
+});
+test("when denominator is zero", () => {
+  assert.equal(isProperFraction(5, 0), "Invalid");
 });

implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js

@@ -10,7 +10,17 @@ test("Valid single-digit card", () => {
 });
 
 test("Arbitrary non-card string", () => {
-  assert.throws(() => getCardValue("invalid"), /Expected a number followed by a suit, but got "invalid"/, "Expected clear error");
+  assert.throws(
+    () => getCardValue("H♠"),
+    /Expected a number followed by a suit, but got "invalid"/,
+    "Expected clear error"
+  );
+});
+test("Valid face card", function () {
+  assert.equal(getCardValue("J♣"), 10);
+});
+test("Valid ace card", function () {
+  assert.equal(getCardValue("A♠"), 11);
 });
 
 // TODO: What other invalid card cases can you think of?

implement-and-rewrite-tests/implement/1-get-angle-type.js

@@ -18,4 +18,36 @@
 
 export function getAngleType(angle) {
   // TODO: Implement this function
+  if (angle === 90) {
+    return "Right angle";
+  } else if (angle > 0 && 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";
+  }
+
+  /*switch (true) {
+    case angle === 90:
+      return "Right angle";
+    case angle > 0 && angle < 90:
+      return "Acute angle";
+    case angle > 90 && angle < 180:
+      return "Obtuse angle";
+    case angle === 180:
+      return "Straight angle";
+    case angle > 180 && angle < 360:
+      return "Reflex angle";
+    case angle === 0:
+      return "Zero angle";
+    case angle === 360:
+      return "Full angle";
+    default:
+      return "Invalid angle";
+  }*/
 }

implement-and-rewrite-tests/implement/2-is-proper-fraction.js

@@ -15,4 +15,17 @@
 
 export function isProperFraction(numerator, denominator) {
   // TODO: Implement this function
+  if (denominator === 0) {
+    return "Invalid";
+  } else if (Math.abs(numerator) < Math.abs(denominator)) {
+    return true;
+  } else return false;
+  /*switch (true) {
+    case denominator === 0:
+      return NaN;
+    case Math.abs(numerator) < Math.abs(denominator):
+      return true;
+    case Math.abs(numerator) >= Math.abs(denominator):
+      return false;
+  }*/
 }

implement-and-rewrite-tests/implement/3-get-card-value.js

@@ -25,4 +25,23 @@
 
 export function getCardValue(card) {
   // TODO: Implement this function
+  const format = /^([AJQK]|[2-9]|10)[♠♥♦♣]$/;
+  if (typeof card === "string" && format.test(card)) {
+    if (parseInt(card) >= 2 && parseInt(card) <= 10) {
+      return parseInt(card);
+    } else if (card[0] === "K" || card[0] === "Q" || card[0] === "J") {
+      return 10;
+    } else if (card[0] === "A") {
+      return 11;
+    }
+    /* switch (true) {
+      case parseInt(card) >= 2 && parseInt(card) <= 10:
+        return parseInt(card);
+      case card[0] === "K" || card[0] === "Q" || card[0] === "J":
+        return 10;
+      case card[0] === "A":
+        return 11;
+    }*/
+  }
+  throw new Error("invalid");
 }

implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js

@@ -12,7 +12,30 @@ test(`should return "Acute angle" when (0 < angle < 90)`, () => {
 });
 
 // Case 2: Right angle
+test(`should return "Right angle" when (angle === 90)`, () => {
+  expect(getAngleType(90)).toEqual("Right angle");
+});
 // Case 3: Obtuse angles
+test(`should return "Obtuse angle" when (90 < angle < 180)`, () => {
+  expect(getAngleType(91)).toEqual("Obtuse angle");
+  expect(getAngleType(120)).toEqual("Obtuse angle");
+  expect(getAngleType(179)).toEqual("Obtuse angle");
+});
 // Case 4: Straight angle
+test(`should return "Straight angle" when (angle === 180)`, () => {
+  expect(getAngleType(180)).toEqual("Straight angle");
+});
 // Case 5: Reflex angles
-// Case 6: Invalid angles
+test(`should return "Reflex angle" when (180 < angle < 360)`, () => {
+  expect(getAngleType(181)).toEqual("Reflex angle");
+  expect(getAngleType(260)).toEqual("Reflex angle");
+  expect(getAngleType(359)).toEqual("Reflex angle");
+});
+
+// Case 8: Invalid angles
+test(`should return "Invalid angle" when (angle <= 0 or angle >= 360)`, () => {
+  expect(getAngleType(400)).toEqual("Invalid angle");
+  expect(getAngleType(-12)).toEqual("Invalid angle");
+  expect(getAngleType(0)).toEqual("Invalid angle");
+  expect(getAngleType(360)).toEqual("Invalid angle");
+});

implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js

@@ -3,6 +3,17 @@ import { isProperFraction } from "../implement/2-is-proper-fraction.js";
 // TODO: Write tests in Jest syntax to cover all combinations of positives, negatives, zeros, and other categories.
 
 // Special case: numerator is zero
-test(`should return false when denominator is zero`, () => {
-  expect(isProperFraction(1, 0)).toEqual(false);
+test(`should return Invalid when denominator is zero`, () => {
+  expect(isProperFraction(1, 0)).toEqual("Invalid");
+});
+test(`should return false when (nominator >= denominator)`, () => {
+  expect(isProperFraction(4, 1)).toEqual(false);
+  expect(isProperFraction(3, 3)).toEqual(false);
+  expect(isProperFraction(2, -1)).toEqual(false);
+  expect(isProperFraction(-4, 1)).toEqual(false);
+});
+test(`should return true when (nominator < denominator)`, () => {
+  expect(isProperFraction(3, 5)).toEqual(true);
+  expect(isProperFraction(3, -5)).toEqual(true);
+  expect(isProperFraction(-2, 7)).toEqual(true);
 });

implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js

@@ -6,6 +6,30 @@ import { getCardValue } from "../implement/3-get-card-value.js";
 test(`Should return 11 when given an ace card`, () => {
   expect(getCardValue("A♠")).toEqual(11);
 });
+// Case 2: number cards (2-10)
+test(`Should return the digit when given number card`, () => {
+  expect(getCardValue("10♠")).toEqual(10);
+  expect(getCardValue("6♠")).toEqual(6);
+  expect(getCardValue("2♠")).toEqual(2);
+});
+// Case 3: face cards
+test(`Should return 10 when given face card`, () => {
+  expect(getCardValue("J♣")).toEqual(10);
+  expect(getCardValue("Q♠")).toEqual(10);
+  expect(getCardValue("K♦")).toEqual(10);
+});
+// Case 4: invalid cards
+test(`Should return invalid when given invalid card`, () => {
+  expect(() => {
+    getCardValue("L♣").toThrow("invalid");
+  });
+  expect(() => {
+    getCardValue("A*").toThrow("invalid");
+  });
+  expect(() => {
+    getCardValue("12♣").toThrow("invalid");
+  });
+});
 
 // Suggestion: Group the remaining test data into these categories:
 //   Number Cards (2-10)
@@ -15,4 +39,3 @@ test(`Should return 11 when given an ace card`, () => {
 // To learn how to test whether a function throws an error as expected in Jest,
 // please refer to the Jest documentation:
 // https://jestjs.io/docs/expect#tothrowerror
-