diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js
index cf50f6cad..20e3ab4de 100644
--- a/implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js
+++ b/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");
+});
+// - "Zero angle" for angles that are at 0°
+test("Classifies Zero angles", () => {
+  const right = getAngleType(0);
+  assert.equal(right, "Zero angle");
+});
+// - "Full angle" for angles that are at 360°
+test("Classifies Full angles", () => {
+  const right = getAngleType(360);
+  assert.equal(right, "Full angle");
+});
diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js
index a29084605..f8c131e50 100644
--- a/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js
+++ b/implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js
@@ -6,7 +6,39 @@ 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 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("Proper fraction with negative numbers: -Numerator < -Denominator", () => {
+  assert.equal(isProperFraction(-1, -2), true);
+});
diff --git a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js
index f5092d9b1..ccc337afa 100644
--- a/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js
+++ b/implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js
@@ -10,7 +10,28 @@ 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
+test("Incorrect card number", () => {
+  assert.throws(
+    () => getCardValue("20"),
+    /Incorrect card number given/,
+    "Incorrect card number given"
+  );
+});
diff --git a/implement-and-rewrite-tests/implement/1-get-angle-type.js b/implement-and-rewrite-tests/implement/1-get-angle-type.js
index 8a6fba050..d8dabbc67 100644
--- a/implement-and-rewrite-tests/implement/1-get-angle-type.js
+++ b/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 "Zero angle";
+  } else if (angle === 360) {
+    return "Full angle";
+  } else if (angle < 0 || angle > 360) {
+    return "Invalid angle";
+  }
 }
diff --git a/implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/implement-and-rewrite-tests/implement/2-is-proper-fraction.js
index f983800f0..95a54d3be 100644
--- a/implement-and-rewrite-tests/implement/2-is-proper-fraction.js
+++ b/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;
 }
diff --git a/implement-and-rewrite-tests/implement/3-get-card-value.js b/implement-and-rewrite-tests/implement/3-get-card-value.js
index 9614ab1ee..e0b63fba5 100644
--- a/implement-and-rewrite-tests/implement/3-get-card-value.js
+++ b/implement-and-rewrite-tests/implement/3-get-card-value.js
@@ -25,4 +25,21 @@
 
 export function getCardValue(card) {
   // TODO: Implement this function
+  let suit = card.slice(-1);
+  let cardNumber = card.slice(0, -1);
+  let value = Number(cardNumber);
+
+  if (card.length >= 4) {
+    throw new Error(`Expected a number followed by a suit, but got "invalid"`);
+  } else 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 (value >= 2 && value <= 10) {
+    return value;
+  } else if (Value > 10) {
+    throw new Error("Incorrect card number given");
+  }
 }
diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
index e0ba786ab..ade30845d 100644
--- a/implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
+++ b/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 "Zero angle" when (angle = 0)`, () => {
+  expect(getAngleType(0)).toEqual("Zero angle");
+});
+// Case 8: Full angles
+test(`should return "Full angle" when (angle = 360)`, () => {
+  expect(getAngleType(360)).toEqual("Full angle");
+});
diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
index 5d49e2d8b..5d6ef14a9 100644
--- a/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
+++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
@@ -3,6 +3,60 @@ 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: 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 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: 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);
+});
diff --git a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
index a6de5a82a..323766bf0 100644
--- a/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
+++ b/implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
@@ -9,10 +9,38 @@ test(`Should return 11 when given an ace card`, () => {
 
 // Suggestion: Group the remaining test data into these categories:
 //   Number Cards (2-10)
+test(`Should return number value when given an numbered card`, () => {
+  expect(getCardValue("2♠")).toEqual(2);
+  expect(getCardValue("7♥")).toEqual(7);
+  expect(getCardValue("9♦")).toEqual(9);
+  expect(getCardValue("5♠")).toEqual(5);
+});
+
 //   Face Cards (J, Q, K)
-//   Invalid Cards
+test(`Should return 10 when given a J, Q, K`, () => {
+  expect(getCardValue("J♠")).toEqual(10);
+  expect(getCardValue("Q♥")).toEqual(10);
+  expect(getCardValue("K♦")).toEqual(10);
+  expect(getCardValue("J♠")).toEqual(10);
+});
 
+//   Invalid Cards
+test(`Should throw error 'expected a number followed by a suit, but got "invalid"' with invalid card`, () => {
+  expect(() => getCardValue("120♥")).toThrow;
+  new Error('expected a number followed by a suit, but got "invalid"');
+  expect(() => getCardValue("203♦")).toThrow;
+  new Error('expected a number followed by a suit, but got "invalid"');
+});
 // 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
 
+test(`Should throw error "Incorrect suit given" when given wrong symbol"`, () => {
+  expect(() => getCardValue("2☺")).toThrow;
+  new Error("Incorrect suit given");
+});
+
+test(`Should throw error "Incorrect card number given" when given wrong 2 digit number"`, () => {
+  expect(() => getCardValue("25♠")).toThrow;
+  new Error("Incorrect card given");
+});