Editing code

Author: Alaa-Tagi

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

@@ -8,8 +8,13 @@
 // write one test at a time, and make it pass, build your solution up methodically
 
 function isProperFraction(numerator, denominator) {
+<<<<<<< HEAD
+  if (denominator) {
+    return true;
+=======
   if (typeof numerator !== "number" || typeof denominator !== "number") {
     return false; // Invalid input types
+>>>>>>> 52740052fb0ad97a2c7253a04978b14a15b9e763
   }
 
   if (denominator === 0) {

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

@@ -1,37 +1,93 @@
 const isProperFraction = require("../implement/2-is-proper-fraction");
 
+<<<<<<< HEAD
+// Case 1: Proper fraction
+// When numerator < denominator, it should return true.
+test("should return true for a proper fraction", () => {
+=======
 // Case 1: Proper Fraction
 // Given a numerator smaller than denominator (2/3),
 // When the function is called,
 // Then it should return true because it's a proper fraction.
 test("should return true for a proper fraction (2/3)", () => {
+>>>>>>> 52740052fb0ad97a2c7253a04978b14a15b9e763
   expect(isProperFraction(2, 3)).toEqual(true);
 });
 
+<<<<<<< HEAD
+// Case 2: Improper fraction
+// When numerator > denominator, it should return false.
+test("should return false for an improper fraction", () => {
+=======
 // Case 2: Improper Fraction
 // Given a numerator greater than denominator (5/2),
 // When the function is called,
 // Then it should return false because it's an improper fraction.
 test("should return false for an improper fraction (5/2)", () => {
+>>>>>>> 52740052fb0ad97a2c7253a04978b14a15b9e763
   expect(isProperFraction(5, 2)).toEqual(false);
 });
 
+<<<<<<< HEAD
+// Case 3: Negative proper fraction
+// When numerator is negative but |numerator| < |denominator|, it should return true.
+test("should return true for a negative proper fraction", () => {
+=======
 // Case 3: Negative Proper Fraction
 // Given a negative proper fraction (-1/2),
 // When the function is called,
 // Then it should return true because the value is between -1 and 1.
 test("should return true for a negative proper fraction (-1/2)", () => {
+>>>>>>> 52740052fb0ad97a2c7253a04978b14a15b9e763
   expect(isProperFraction(-1, 2)).toEqual(true);
 });
 
+<<<<<<< HEAD
+// Case 4: Equal numerator and denominator
+// When numerator === denominator, it should return false.
+test("should return false for equal numerator and denominator", () => {
+=======
 // Case 4: Equal Numerator and Denominator
 // Given a numerator equal to denominator (3/3),
 // When the function is called,
 // Then it should return false because it's equal to 1 (not proper).
 test("should return false for equal numerator and denominator (3/3)", () => {
+>>>>>>> 52740052fb0ad97a2c7253a04978b14a15b9e763
   expect(isProperFraction(3, 3)).toEqual(false);
 });
 
+<<<<<<< HEAD
+// Case 5: Zero numerator
+// 0 divided by any non-zero denominator is a proper fraction.
+test("should return true for zero numerator", () => {
+  expect(isProperFraction(0, 5)).toEqual(true);
+});
+
+// Case 6: Negative denominator
+// When denominator is negative, the fraction is still valid, so check absolute values.
+test("should return true when denominator is negative but |numerator| < |denominator|", () => {
+  expect(isProperFraction(2, -3)).toEqual(true);
+});
+
+// Case 7: Denominator is zero
+// Division by zero is undefined, should return false.
+test("should return false when denominator is zero", () => {
+  expect(isProperFraction(3, 0)).toEqual(false);
+});
+
+// Case 8: Both numerator and denominator are negative but |numerator| < |denominator|
+// Negative/negative cancels out, still a proper fraction.
+test("should return true when both numerator and denominator are negative and |numerator| < |denominator|", () => {
+  expect(isProperFraction(-3, -7)).toEqual(true);
+});
+
+// Case 9: Large numbers
+// It should handle large numbers correctly.
+test("should return true for large proper fractions", () => {
+  expect(isProperFraction(999, 1000)).toEqual(true);
+});
+
+=======
 // Case 5: Negative Improper Fraction
 // Given a negative improper fraction (-4/3),
 // When the function is called,
@@ -63,3 +119,5 @@ test("should return true for zero numerator (0/5)", () => {
 test("should return false for zero denominator (5/0)", () => {
   expect(isProperFraction(5, 0)).toEqual(false);
 });
+
+>>>>>>> 52740052fb0ad97a2c7253a04978b14a15b9e763

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

@@ -8,6 +8,39 @@ test("should return 11 for Ace of Spades", () => {
 });
 
 // Case 2: Handle Number Cards (2-10):
+test("should return 7 for 7 of Hearts", () => {
+  const sevenOfHearts = getCardValue("7♥");
+  expect(sevenOfHearts).toEqual(7);
+});
 // Case 3: Handle Face Cards (J, Q, K):
+test("should return 10 for Jack of Diamonds", () => {
+  const jackOfDiamonds = getCardValue("J♦");
+  expect(jackOfDiamonds).toEqual(10);
+});
+
+//Case 4
+test("should return 10 for Queen of Clubs", () => {
+  const queenOfClubs = getCardValue("Q♣");
+  expect(queenOfClubs).toEqual(10);
+});
+
+test("should return 10 for King of Spades", () => {
+  const kingOfSpades = getCardValue("K♠");
+  expect(kingOfSpades).toEqual(10);
+});
+
 // Case 4: Handle Ace (A):
+test("should return 11 for Ace of Diamonds", () => {
+  const aceOfDiamonds = getCardValue("A♦");
+  expect(aceOfDiamonds).toEqual(11);
+});
 // Case 5: Handle Invalid Cards:
+test("should return null for invalid card '1X'", () => {
+  const invalidCard1 = getCardValue("1X");
+  expect(invalidCard1).toBe("Invalid card rank");
+});
+test("should return null for invalid card '11H'", () => {
+  const invalidCard2 = getCardValue("11H");
+  expect(invalidCard2).toBe("Invalid card rank");
+});
+