London | 26-Sept | Hugh Mills | Sprint 2 | Implement and rewrite tests

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

@@ -10,3 +10,40 @@ test("Classifies right angles", () => {
   const right = getAngleType(90);
   assert.equal(right, "Right angle");
 });
+// "Acute angle" for angles greater than 0° and less than 90°
+test("Classifies Acute angles", () => {
+  const right = getAngleType(45);
+  assert.equal(right, "Acute angle");
+});
+// - "Obtuse angle" for angles greater than 90° and less than 180°
+test("Classifies Obtuse angles", () => {
+  const right = getAngleType(135);
+  assert.equal(right, "Obtuse angle");
+});
+// - "Straight angle" for exactly 180°
+test("Classifies Straight angles", () => {
+  const right = getAngleType(180);
+  assert.equal(right, "Straight angle");
+});
+// - "Reflex angle" for angles greater than 180° and less than 360°
+test("Classifies Reflex angles", () => {
+  const right = getAngleType(225);
+  assert.equal(right, "Reflex angle");
+});
+// - "Invalid angle" for angles outside the valid range.
+test("Classifies Invalid angles", () => {
+  const right = getAngleType(361);
+  assert.equal(right, "Invalid angle");
+  const right = getAngleType(-361);
+  assert.equal(right, "Invalid angle");
+});
+// - "Invalid angle" for angles that are at 0°
+test("Classifies Invalid angles for 0", () => {
+  const right = getAngleType(0);
+  assert.equal(right, "Invalid angle");
+});
+// - "Invalid angle" for angles that are at 360°
+test("Classifies Invalid angles for 360", () => {
+  const right = getAngleType(360);
+  assert.equal(right, "Invalid angle");
+});

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

@@ -6,7 +6,63 @@ import { isProperFraction } from "../implement/2-is-proper-fraction.js";
 // TODO: Write tests to cover all cases.
 // What combinations of numerators and denominators should you test?
 
-test("Basic proper fraction", () => {
+test("Basic proper fraction: Numerator < Denominator", () => {
   // Example: 1/2 is a proper fraction
   assert.equal(isProperFraction(1, 2), true);
 });
+
+test("Improper fraction: Numerator = Denominator", () => {
+  assert.equal(isProperFraction(2, 2), false);
+});
+
+test("Improper negative fraction: Numerator = Denominator", () => {
+  assert.equal(isProperFraction(-2, -2), false);
+});
+
+test("improper fraction: Numerator > Denominator", () => {
+  assert.equal(isProperFraction(2, 1), false);
+});
+
+test("Improper fraction: Denominator = 0", () => {
+  assert.equal(isProperFraction(1, 0), false);
+});
+
+test("Improper fraction: Nominator = 0", () => {
+  assert.equal(isProperFraction(0, 2), false);
+});
+
+test("Proper fraction with negative number: -Numerator < Denominator", () => {
+  assert.equal(isProperFraction(-1, 2), true);
+});
+
+test("Proper fraction with negative number: Numerator < -Denominator", () => {
+  assert.equal(isProperFraction(1, -2), true);
+});
+
+test("Improper fraction with negative number: -Numerator > Denominator", () => {
+  assert.equal(isProperFraction(-2, 1), false);
+});
+
+test("Improper fraction with negative number: Numerator > -Denominator", () => {
+  assert.equal(isProperFraction(2, -1), false);
+});
+
+test("Proper fraction with negative numbers: -Numerator < -Denominator", () => {
+  assert.equal(isProperFraction(-1, -2), true);
+});
+
+test("Proper fraction with negative Numerator and Zero: -Numerator < 0", () => {
+  assert.equal(isProperFraction(-1, 0), false);
+});
+
+test("Proper fraction with Zero and negative Denominator: 0 < -Denominator", () => {
+  assert.equal(isProperFraction(0, -2), false);
+});
+
+test("Proper fraction with both being Zero", () => {
+  assert.equal(isProperFraction(0, 0), false);
+});
+
+test("Improper fraction with negative numbers: -Numerator > -Denominator", () => {
+  assert.equal(isProperFraction(-3, -2), false);
+});

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

@@ -10,7 +10,52 @@ 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("invalid"),
+    /Expected a number followed by a suit, but got "invalid"/,
+    "Expected clear error"
+  );
 });
 
 // TODO: What other invalid card cases can you think of?
+//Incorrect suit
+test("Incorrect suit", () => {
+  assert.throws(
+    () => getCardValue("2☺"),
+    /Incorrect suit given/,
+    "Incorrect suit"
+  );
+});
+
+//Incorrect card value to high
+test("Incorrect card number: High value", () => {
+  assert.throws(
+    () => getCardValue("20♦"),
+    /Incorrect card number given/,
+    "Incorrect card number given"
+  );
+});
+//Incorrect card value when negative
+test("Incorrect card number: Negative Number", () => {
+  assert.throws(
+    () => getCardValue("-2♦"),
+    /Incorrect card number given/,
+    "Incorrect card number given"
+  );
+});
+//Incorrect card value when symbol
+test("Incorrect card number: Symbol", () => {
+  assert.throws(
+    () => getCardValue("🐱♦"),
+    /Incorrect card number given/,
+    "Incorrect card number given"
+  );
+});
+//Incorrect card value when letter
+test("Incorrect card number: Letter", () => {
+  assert.throws(
+    () => getCardValue("H♦"),
+    /Incorrect card number given/,
+    "Incorrect card number given"
+  );
+});

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

@@ -18,4 +18,21 @@
 
 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 if (angle === 0) {
+    return "Invalid angle";
+  } else if (angle === 360) {
+    return "Invalid angle";
+  } else (angle < 0 || angle > 360) {
+    return "Invalid angle";
+  }
 }

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

@@ -15,4 +15,12 @@
 
 export function isProperFraction(numerator, denominator) {
   // TODO: Implement this function
+  if (denominator === 0) {
+    return false;
+  } else if (numerator === 0) {
+    return false;
+  } else if (Math.abs(numerator) >= Math.abs(denominator)) {
+    return false;
+  }
+  return true;
 }

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

@@ -25,4 +25,25 @@
 
 export function getCardValue(card) {
   // TODO: Implement this function
+  if (card.length >= 4) {
+    throw new Error(`expected a number followed by a suit, but got "invalid"`);
+  }
+
+  let suit = card.slice(-1);
+  let cardNumber = card.slice(0, -1);
+  let value = Number(cardNumber);
+
+  if (!(suit === "♠" || suit === "♥" || suit === "♦" || suit === "♣")) {
+    throw new Error("Incorrect suit given");
+  } else if (cardNumber === "J" || cardNumber === "Q" || cardNumber === "K") {
+    return 10;
+  } else if (cardNumber === "A") {
+    return 11;
+  } else if (Number.isNaN(value)) {
+    throw new Error("Incorrect card number given");
+  } else if (value >= 2 && value <= 10) {
+    return value;
+  } else if (value < 2 || value > 10) {
+    throw new Error("Incorrect card number given");
+  }
 }

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

@@ -12,7 +12,36 @@ 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
-// Case 4: Straight angle
+test(`should return "Obtuse angle" when (90 < angle < 180)`, () => {
+  expect(getAngleType(91)).toEqual("Obtuse angle");
+  expect(getAngleType(167)).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
+test(`should return "Right angle" when (180 < angle < 360)`, () => {
+  expect(getAngleType(186)).toEqual("Reflex angle");
+  expect(getAngleType(270)).toEqual("Reflex angle");
+  expect(getAngleType(359)).toEqual("Reflex angle");
+});
 // Case 6: Invalid angles
+test(`should return "Invalid angle" when (0 > angle > 360)`, () => {
+  expect(getAngleType(361)).toEqual("Invalid angle");
+  expect(getAngleType(396)).toEqual("Invalid angle");
+  expect(getAngleType(-57)).toEqual("Invalid angle");
+});
+// Case 7: Zero angles
+test(`should return "Invalid angle" when (angle = 0)`, () => {
+  expect(getAngleType(0)).toEqual("Invalid angle");
+});
+// Case 8: Full angles
+test(`should return "Invalid angle" when (angle = 360)`, () => {
+  expect(getAngleType(360)).toEqual("Invalid angle");
+});

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

@@ -3,6 +3,107 @@ 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`, () => {
+test(`should return false when numerator is zero`, () => {
   expect(isProperFraction(1, 0)).toEqual(false);
 });
+
+// Special case: denominator is zero
+test(`should return false when denominator is zero`, () => {
+  expect(isProperFraction(0, 1)).toEqual(false);
+});
+
+// Special case: both are zero
+test(`should return false when denominator is zero`, () => {
+  expect(isProperFraction(0, 0)).toEqual(false);
+});
+
+// Special case: Basic proper fraction: Numerator < Denominator
+test(`should return true when: Numerator < Denominator`, () => {
+  expect(isProperFraction(1, 2)).toEqual(true);
+  expect(isProperFraction(3, 6)).toEqual(true);
+  expect(isProperFraction(45, 60)).toEqual(true);
+});
+
+// Special case: Basic proper negative fraction: -Numerator < Denominator
+test(`should return true when: Numerator < Denominator`, () => {
+  expect(isProperFraction(-1, 2)).toEqual(true);
+  expect(isProperFraction(-3, 6)).toEqual(true);
+  expect(isProperFraction(-45, 60)).toEqual(true);
+});
+
+// Special case: Basic proper negative fraction: Numerator < -Denominator
+test(`should return true when: Numerator < Denominator`, () => {
+  expect(isProperFraction(1, -2)).toEqual(true);
+  expect(isProperFraction(3, -6)).toEqual(true);
+  expect(isProperFraction(45, -60)).toEqual(true);
+});
+
+// Special case: Improper fraction: Numerator = Denominator
+test(`should return false when: Numerator = Denominator`, () => {
+  expect(isProperFraction(1, 1)).toEqual(false);
+  expect(isProperFraction(12, 12)).toEqual(false);
+  expect(isProperFraction(56, 56)).toEqual(false);
+});
+
+// Special case: Improper negative fraction: -Numerator = -Denominator
+test(`should return false when: Numerator = Denominator`, () => {
+  expect(isProperFraction(-1, -1)).toEqual(false);
+  expect(isProperFraction(-12, -12)).toEqual(false);
+  expect(isProperFraction(-56, -56)).toEqual(false);
+});
+
+// Special case: Improper fraction: Numerator > Denominator
+test(`should return false when: Numerator > Denominator`, () => {
+  expect(isProperFraction(3, 2)).toEqual(false);
+  expect(isProperFraction(7, 4)).toEqual(false);
+  expect(isProperFraction(30, 20)).toEqual(false);
+});
+
+// Special case: Proper fraction with negative number: -Numerator < Denominator
+test(`should return true when: -Numerator < Denominator`, () => {
+  expect(isProperFraction(-1, 2)).toEqual(true);
+  expect(isProperFraction(-6, 8)).toEqual(true);
+  expect(isProperFraction(-10, 20)).toEqual(true);
+});
+
+// Special case: Proper fraction with both negative number: -Numerator < -Denominator
+test(`should return true when: -Numerator < -Denominator`, () => {
+  expect(isProperFraction(-1, -2)).toEqual(true);
+  expect(isProperFraction(-6, -8)).toEqual(true);
+  expect(isProperFraction(-10, -20)).toEqual(true);
+});
+
+// Special case: Improper fraction with negative number: Numerator > -Denominator
+test(`should return false when: -Numerator > Denominator`, () => {
+  expect(isProperFraction(2, -1)).toEqual(false);
+  expect(isProperFraction(5, -4)).toEqual(false);
+  expect(isProperFraction(20, -10)).toEqual(false);
+});
+
+// Special case: Improper fraction with negative number: Numerator > -Denominator
+test(`should return false when: -Numerator > Denominator`, () => {
+  expect(isProperFraction(-2, 1)).toEqual(false);
+  expect(isProperFraction(-5, 4)).toEqual(false);
+  expect(isProperFraction(-20, 10)).toEqual(false);
+});
+
+// Special case: Improper fraction with both negative: -Numerator > -Denominator
+test(`should return false when: -Numerator > Denominator`, () => {
+  expect(isProperFraction(-2, -1)).toEqual(false);
+  expect(isProperFraction(-5, -4)).toEqual(false);
+  expect(isProperFraction(-20, -10)).toEqual(false);
+});
+
+// Special case: Improper fraction with negative Numerator and 0: -Numerator > 0
+test(`should return false when: -Numerator > Denominator`, () => {
+  expect(isProperFraction(-2, 0)).toEqual(false);
+  expect(isProperFraction(-5, 0)).toEqual(false);
+  expect(isProperFraction(-20, 0)).toEqual(false);
+});
+
+// Special case: Improper fraction with 0 and negative Denominator: 0 > -Denominator
+test(`should return false when: -Numerator > Denominator`, () => {
+  expect(isProperFraction(0, -1)).toEqual(false);
+  expect(isProperFraction(0, -4)).toEqual(false);
+  expect(isProperFraction(0, -10)).toEqual(false);
+});