Complete TDD practice exercises

Author: serveyano

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

@@ -15,15 +15,13 @@
 // execute the code to ensure all tests pass.
 
 function getAngleType(angle) {
-  
   // TODO: Implement this function
 }
 
 // The line below allows us to load the getAngleType function into tests in other files.
 // This will be useful in the "rewrite tests with jest" step.
 module.exports = getAngleType;
 
-
 // This helper function is written to make our assertions easier to read.
 // If the actual output matches the target output, the test will pass
 function assertEquals(actualOutput, targetOutput) {
@@ -35,23 +33,5 @@ function assertEquals(actualOutput, targetOutput) {
 
 // TODO: Write tests to cover all cases, including boundary and invalid cases.
 // Example: Identify Right Angles
-
-// Acute angles
-assertEquals(getAngleType(45), "Acute angle");
-
-// Right angle
-assertEquals(getAngleType(90), "Right angle");
-
-// Obtuse angle
-assertEquals(getAngleType(120), "Obtuse angle");
-
-// Straight angle
-assertEquals(getAngleType(180), "Straight angle");
-
-// Reflex angle
-assertEquals(getAngleType(270), "Reflex angle");
-
-// Invalid angles
-assertEquals(getAngleType(0), "Invalid angle");
-assertEquals(getAngleType(360), "Invalid angle");
-assertEquals(getAngleType(-45), "Invalid angle");
+const right = getAngleType(90);
+assertEquals(right, "Right angle");

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

@@ -11,11 +11,9 @@
 // execute the code to ensure all tests pass.
 
 function isProperFraction(numerator, denominator) {
-    if (denominator === 0) {
-    return false;
-}
- return numerator < denominator;
+  // TODO: Implement this function
 }
+
 // The line below allows us to load the isProperFraction function into tests in other files.
 // This will be useful in the "rewrite tests with jest" step.
 module.exports = isProperFraction;
@@ -33,22 +31,3 @@ function assertEquals(actualOutput, targetOutput) {
 
 // Example: 1/2 is a proper fraction
 assertEquals(isProperFraction(1, 2), true);
-
-
-// Numerator equals denominator
-assertEquals(isProperFraction(2, 2), false);
-
-// Improper fraction
-assertEquals(isProperFraction(5, 3), false);
-
-// Zero numerator
-assertEquals(isProperFraction(0, 5), true);
-
-// Denominator is zero
-assertEquals(isProperFraction(1, 0), false);
-
-// Another proper fraction
-assertEquals(isProperFraction(3, 4), true);
-
-// Another improper fraction
-assertEquals(isProperFraction(10, 4), false);

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

@@ -22,30 +22,7 @@
 // execute the code to ensure all tests pass.
 
 function getCardValue(card) {
-const rank = card.slice(0, -1);
-  const suit = card.slice(-1);
-
-  const validSuits = ["♠", "♥", "♦", "♣"];
-
-  if (!validSuits.includes(suit)) {
-    throw new Error("Invalid card");
-  }
-
-  if (rank === "A") {
-    return 11;
-  }
-
-  if (rank === "J" || rank === "Q" || rank === "K") {
-    return 10;
-  }
-
-  const value = Number(rank);
-
-  if (value >= 2 && value <= 10) {
-    return value;
-  }
-
-  throw new Error("Invalid card");
+  // TODO: Implement this function
 }
 
 // The line below allows us to load the getCardValue function into tests in other files.
@@ -63,21 +40,10 @@ function assertEquals(actualOutput, targetOutput) {
 // TODO: Write tests to cover all outcomes, including throwing errors for invalid cards.
 // Examples:
 assertEquals(getCardValue("9♠"), 9);
-assertEquals(getCardValue("2♠"), 2);
-assertEquals(getCardValue("10♥"), 10);
-
-// Face cards
-assertEquals(getCardValue("J♣"), 10);
-assertEquals(getCardValue("Q♦"), 10);
-assertEquals(getCardValue("K♥"), 10);
-
-// Ace
-assertEquals(getCardValue("A♠"), 11);
 
 // Handling invalid cards
 try {
   getCardValue("invalid");
-  
 
   // This line will not be reached if an error is thrown as expected
   console.error("Error was not thrown for invalid card 😢");
@@ -86,30 +52,3 @@ try {
 }
 
 // What other invalid card cases can you think of?
-try {
-  getCardValue("1♠");
-  console.error("Error was not thrown 😢");
-} catch (e) {
-  console.log("Error thrown 🎉");
-}
-
-try {
-  getCardValue("11♠");
-  console.error("Error was not thrown 😢");
-} catch (e) {
-  console.log("Error thrown 🎉");
-}
-
-try {
-  getCardValue("A");
-  console.error("Error was not thrown 😢");
-} catch (e) {
-  console.log("Error thrown 🎉");
-}
-
-try {
-  getCardValue("5X");
-  console.error("Error was not thrown 😢");
-} catch (e) {
-  console.log("Error thrown 🎉");
-}

Sprint-3/2-practice-tdd/count.js

@@ -1,5 +1,14 @@
 function countChar(stringOfCharacters, findCharacter) {
-  return 5
+let count = 0;
+
+
+ for (let i = 0; i < stringOfCharacters.length; i++) {
+   if (stringOfCharacters[i] === findCharacter) {
+     count++;
+   }
+ }
+ return count;
 }
 
+
 module.exports = countChar;

Sprint-3/2-practice-tdd/count.test.js

@@ -5,20 +5,21 @@ const countChar = require("./count");
 // Then it should:
 
 // Scenario: Multiple Occurrences
-// Given the input string `str`,
-// And a character `char` that occurs one or more times in `str` (e.g., 'a' in 'aaaaa'),
-// When the function is called with these inputs,
-// Then it should correctly count occurrences of `char`.
-
 test("should count multiple occurrences of a character", () => {
-  const str = "aaaaa";
-  const char = "a";
-  const count = countChar(str, char);
-  expect(count).toEqual(5);
+ const str = "aaaaa";
+ const char = "a";
+ const count = countChar(str, char);
+ expect(count).toEqual(5);
 });
 
+
 // Scenario: No Occurrences
-// Given the input string `str`,
-// And a character `char` that does not exist within `str`.
-// When the function is called with these inputs,
-// Then it should return 0, indicating that no occurrences of `char` were found.
+test("should return 0 when character does not exist in string", () => {
+ const str = "hello";
+ const char = "z";
+ const count = countChar(str, char);
+
+
+ expect(count).toEqual(0);
+});
+

Sprint-3/2-practice-tdd/get-ordinal-number.js

@@ -1,5 +1,23 @@
 function getOrdinalNumber(num) {
-  return "1st";
+  if (num % 100 >= 11 && num % 100 <= 13) {
+   return `${num}th`;
+}
+ if (num % 10 === 1) {
+  return `${num}st`;
+ }
+
+
+ if (num % 10 === 2) {
+   return `${num}nd`;
+ }
+
+
+ if (num % 10 === 3) {
+   return `${num}rd`;
+ }
+
+
+ return `${num}th`;
 }
 
 module.exports = getOrdinalNumber;

Sprint-3/2-practice-tdd/get-ordinal-number.test.js

@@ -18,3 +18,67 @@ test("should append 'st' for numbers ending with 1, except those ending with 11"
   expect(getOrdinalNumber(21)).toEqual("21st");
   expect(getOrdinalNumber(131)).toEqual("131st");
 });
+
+// Case 2: Numbers ending with 2 (but not 12)
+test("should append 'nd' for numbers ending with 2, except those ending with 12", () => {
+ expect(getOrdinalNumber(112)).toEqual("112th");
+ expect(getOrdinalNumber(32)).toEqual("32nd");
+ expect(getOrdinalNumber(332)).toEqual("332nd");
+});
+
+
+// Case 3: Numbers ending with 3 (but not 13)
+test("should append 'rd' for numbers ending with 3, except those ending with 13", () => {
+ expect(getOrdinalNumber(113)).toEqual("113th");
+ expect(getOrdinalNumber(23)).toEqual("23rd");
+ expect(getOrdinalNumber(453)).toEqual("453rd");
+});
+
+
+// Case 4: Numbers ending  with 4 -9
+test("should append 'th' for numbers ending with 4", () => {
+ expect(getOrdinalNumber(124)).toEqual("124th");
+ expect(getOrdinalNumber(235)).toEqual("235th");
+ expect(getOrdinalNumber(16)).toEqual("16th");
+ expect(getOrdinalNumber(17)).toEqual("17th");
+ expect(getOrdinalNumber(18)).toEqual("18th");
+ expect(getOrdinalNumber(19)).toEqual("19th");
+});
+
+
+
+
+// Case 5: Numbers ending with 11, 12, 13
+test("should append 'th' for numbers ending with 11, 12, 13", () => {
+ expect(getOrdinalNumber(11)).toEqual("11th");
+ expect(getOrdinalNumber(12)).toEqual("12th");
+ expect(getOrdinalNumber(13)).toEqual("13th");
+ expect(getOrdinalNumber(111)).toEqual("111th");
+ expect(getOrdinalNumber(112)).toEqual("112th");
+ expect(getOrdinalNumber(113)).toEqual("113th");
+});
+
+
+// Case 6: Numbers ending with 0
+test("should append 'th' for numbers ending with 0", () => {
+ expect(getOrdinalNumber(10)).toEqual("10th");
+ expect(getOrdinalNumber(20)).toEqual("20th");
+ expect(getOrdinalNumber(30)).toEqual("30th");
+ expect(getOrdinalNumber(140)).toEqual("140th");
+});
+function repeatStr() {
+   let result = "";
+
+
+ for (let i = 0; i < num; i++) {
+   result += str;
+ }
+
+
+ return result;
+}
+
+
+module.exports = repeatStr;
+
+

Sprint-3/2-practice-tdd/repeat-str.js

@@ -1,7 +1,11 @@
 function repeatStr() {
-  // Your implementation of this function must *not* call String.prototype.repeat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat).
-  // The goal is to re-implement that function, not to use it.
-  return "hellohellohello";
+  let result = "";
+
+  for (let i = 0; i < n; i++) {
+    result += str;
+  }
+
+  return result;
 }
 
 module.exports = repeatStr;

Sprint-3/2-practice-tdd/repeat-str.test.js

@@ -20,13 +20,47 @@ test("should repeat the string count times", () => {
 // Given a target string `str` and a `count` equal to 1,
 // When the repeatStr function is called with these inputs,
 // Then it should return the original `str` without repetition.
+test("should return the original string when count is 1", () => {
+ const str = "hello";
+ const count = 1;
+ const repeatedStr = repeatStr(str, count);
+
+
+ expect(repeatedStr).toEqual("hello");
+});
 
 // Case: Handle count of 0:
 // Given a target string `str` and a `count` equal to 0,
 // When the repeatStr function is called with these inputs,
 // Then it should return an empty string.
+test("should return an empty string when count is 0", () => {
+ const str = "hello";
+ const count = 0;
+ const repeatedStr = repeatStr(str, count);
+
+
+ expect(repeatedStr).toEqual("");
+});
 
 // Case: Handle negative count:
 // Given a target string `str` and a negative integer `count`,
 // When the repeatStr function is called with these inputs,
 // Then it should throw an error, as negative counts are not valid.
+
+
+function repeatStr() {
+   let result = "";
+
+
+ for (let i = 0; i < num; i++) {
+   result += str;
+ }
+
+
+ return result;
+}
+
+
+module.exports = repeatStr;
+
+