Cape Town| 26-ITP-May|Enice Mutanda| Sprint 3 |Implement-And-Rewrite Tests

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

@@ -1,3 +1,4 @@
+
 // Implement a function getAngleType
 //
 // When given an angle in degrees, it should return a string indicating the type of angle:
@@ -16,6 +17,19 @@
 
 function getAngleType(angle) {
   // TODO: Implement this function
+  if (angle > 0 && angle < 90)
+    return "Acute angle";
+  else if (angle === 90)
+    return "Right 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";
+
 }
 
 // The line below allows us to load the getAngleType function into tests in other files.
@@ -35,3 +49,21 @@ function assertEquals(actualOutput, targetOutput) {
 // Example: Identify Right Angles
 const right = getAngleType(90);
 assertEquals(right, "Right angle");
+
+const acute = getAngleType(45);
+assertEquals(acute, 'Acute angle');
+
+const obtuse = getAngleType(120);
+assertEquals(obtuse,'obtuse angle')
+
+const straight = getAngleType(180); 
+assertEquals(straight, 'Straight angle');
+
+const reflex = getAngleType(270);
+assertEquals(reflex, 'Reflex angle');
+
+const invalid1 = getAngleType(-10);
+assertEquals(invalid1, 'Invalid angle');
+
+const invalid2 = getAngleType(400);
+assertEquals(invalid2, 'Invalid angle');

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

@@ -12,6 +12,14 @@
 
 function isProperFraction(numerator, denominator) {
   // TODO: Implement this function
+  if (denominator === 0){
+    return fasle;
+
+  }
+  if (numerator < denominator && numerator > 0){
+    return true;
+  }
+  return false;
 }
 
 // The line below allows us to load the isProperFraction function into tests in other files.
@@ -31,3 +39,15 @@ function assertEquals(actualOutput, targetOutput) {
 
 // Example: 1/2 is a proper fraction
 assertEquals(isProperFraction(1, 2), true);
+
+// exapmle : 4/3 is not a proper fraction
+assertEquals(isProperFraction(4, 3), false);
+
+// example: 6/5 is not a proper fraction
+assertEquals(isProperFraction(6, 5), false);
+
+// example: 0/5 is a proper fraction
+assertEquals(isProperFraction(0, 5), true);
+
+// example: 5/0 is not a proper fraction
+assertEquals(isProperFraction(5, 0), false);

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

@@ -23,6 +23,21 @@
 
 function getCardValue(card) {
   // TODO: Implement this function
+  if(card === "A♠" || card === "A♥" || card === "A♦" || card === "A♣"){
+    return 11;
+  }
+  else if(card === "J♠" || card === "J♥" || card === "J♦" || card === "J♣" || card === "Q♠" || card === "Q♥" || card === "Q♦" || card === "Q♣" || card === "K♠" || card === "K♥" || card === "K♦" || card === "K♣"){
+    return 10;
+  }
+  else if(card === "2♠" || card === "2♥" || card === "2♦" || card === "2♣"){
+    return 2;
+  }
+  else if(card === "3♠" || card === "3♥" || card === "3♦" || card === "3♣"){
+    return 3;
+  }
+  else {
+    throw new Error("Invalid card");
+  }
 }
 
 // The line below allows us to load the getCardValue function into tests in other files.
@@ -46,9 +61,34 @@ 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 😢");
+  console.error("Error was not thrown for invalid card ");
 } catch (e) {
-  console.log("Error thrown for invalid card 🎉");
+  console.log("Error thrown for invalid card ");
 }
 
+assertEquals(getCardValue("A♠"), 11);
+assertEquals(getCardValue("J♣"), 10);
+assertEquals(getCardValue("Q♦"), 10);
+assertEquals(getCardValue("K♥"), 10);
+assertEquals(getCardValue("2♠"), 2);
+assertEquals(getCardValue("3♥"), 3);
+
+// What other valid card cases can you think of?
+function assertEqual(func, valid message){
+ try{
+  func();
+  console.log("Valid card test passed ");
+ }
 // What other invalid card cases can you think of?
+ function  assertThrows(func, errorMessage) {
+  try {
+    func();
+    console.error("Error was not thrown ");
+  } catch (e) {
+    if (e.message === errorMessage) {
+      console.log("Error thrown as expected ");
+    } else {
+      console.error(`Unexpected error message: ${e.message}`);
+    }
+  }
+}

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

@@ -6,15 +6,36 @@ const getAngleType = require("../implement/1-get-angle-type");
 // including boundary and invalid cases.
 
 // Case 1: Acute angles
-test(`should return "Acute angle" when (0 < angle < 90)`, () => {
+test(`should return "Acute angle" when (0 < angle && angle  < 90)`, () => {
   // Test various acute angles, including boundary cases
   expect(getAngleType(1)).toEqual("Acute angle");
   expect(getAngleType(45)).toEqual("Acute angle");
   expect(getAngleType(89)).toEqual("Acute angle");
 });
 
 // Case 2: Right angle
+test (`should return "right angle" when (angle === 90)`,() => {
+  // testing various angles ,including boundary cases
+  expect( getAngleType(90)).toEqual("right angle");
+  });
 // Case 3: Obtuse angles
+test (`should return "obtuse angle" when (90 < angle && angle < 180)`, () => {
+expect(getAngleType(91)).toEqual("obtuse angle");
+expect(getAngleType(125)).toEqual("obtuse angle");
+expect(getAngleType(172)).toEqual("obtuse angle");
+});
 // Case 4: Straight angle
-// Case 5: Reflex angles
+test(`should return "straight angle" when (angle === 180)`, () => {
+  expect(getAngleType(180)).toEqual("straight angle");
+});
+// Case 5: Reflex angles\
+test(`should return "reflex angle" when (180 < angle && angle < 360)`, () => {
+  expect(getAngleType(181)).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 (angle < 0 || angle > 360)`, () => {
+  expect(getAngleType(-1)).toEqual("Invalid angle");
+  expect(getAngleType(361)).toEqual("Invalid angle");
+});

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

@@ -8,3 +8,17 @@ const isProperFraction = require("../implement/2-is-proper-fraction");
 test(`should return false when denominator is zero`, () => {
   expect(isProperFraction(1, 0)).toEqual(false);
 });
+
+// special case : numerator is one 
+test(` should return true when the numerator is one and denominator is greater than one`, () => {
+  expect(isProperFraction(1, 2)).toEqual(true);
+});
+// special case : denominator is negative to the numerator
+test(`should return false when the denominator is negative and the numerator is positive`, () => {
+  expect(isProperFraction(1, -2)).toEqual(false);
+});
+
+// special case : denominator  is negative to the numerator
+test(`should return false when the numerator is negative and the denominator is positive`, () => {
+  expect(isProperFraction(-1, 2)).toEqual(false);
+});

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

@@ -9,10 +9,24 @@ test(`Should return 11 when given an ace card`, () => {
   expect(getCardValue("A♠")).toEqual(11);
 });
 
-// Suggestion: Group the remaining test data into these categories:
-//   Number Cards (2-10)
-//   Face Cards (J, Q, K)
-//   Invalid Cards
+// case 2 : face cards (J, Q, K)
+test(`Should return 10 when given a face card`, () => {
+  expect(getCardValue("J♠")).toEqual(10);
+  expect(getCardValue("Q♥")).toEqual(10);
+  expect(getCardValue("K♦")).toEqual(10);
+});
+
+// Case 3: Number Cards (2-10)
+test(`Should return the correct value when given a number card`, () => {
+  expect(getCardValue("2♠")).toEqual(2);
+  expect(getCardValue("5♥")).toEqual(5);
+  expect(getCardValue("10♦")).toEqual(10);
+});
+
+// Case 4: Invalid Cards
+test(`Should throw an error when given an invalid card`, () => {
+  expect(() => getCardValue("invalid")).toThrow("Invalid card");
+});
 
 // To learn how to test whether a function throws an error as expected in Jest,
 // please refer to the Jest documentation:

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

@@ -3,3 +3,9 @@ function countChar(stringOfCharacters, findCharacter) {
 }
 
 module.exports = countChar;
+ test( "should count multiple occurrences of a character ", function(){
+  const stringofcharacters = "aaaaa";
+  const findcharcaters = "a";
+  const count = countChar(stringofcharacters, findcharcaters);
+  expect(count).toEqual(5);
+ });

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

@@ -3,6 +3,15 @@ const countChar = require("./count");
 // Given a string `str` and a single character `char` to search for,
 // When the countChar function is called with these inputs,
 // Then it should:
+function CountChar(str, char) {
+  let count = 0;
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === char) {
+      count++;
+    }
+  }
+  return count;
+}
 
 // Scenario: Multiple Occurrences
 // Given the input string `str`,
@@ -22,3 +31,9 @@ test("should count multiple occurrences of a character", () => {
 // 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 the character does not occur in the string', () => {
+  const str = "hello";
+  const char = "x";
+  const count = countChar(str, char);
+  expect(count).toEqual(5);
+});

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

@@ -3,3 +3,13 @@ function getOrdinalNumber(num) {
 }
 
 module.exports = getOrdinalNumber;
+ test(`works with any number ending with 1, except for 11. For all other numbers, it should return the number followed by "th"  with exceptions to 2 and 3 `, () => {
+   expect(getOrdinalNumber(1)).toBe("1st");
+   expect(getOrdinalNumber(2)).toBe("2nd");
+   expect(getOrdinalNumber(3)).toBe("3rd");
+   expect(getOrdinalNumber(4)).toBe("4th");
+   expect(getOrdinalNumber(11)).toBe("11th");
+   expect(getOrdinalNumber(12)).toBe("12th");
+ });
+
+

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

@@ -15,6 +15,18 @@ const getOrdinalNumber = require("./get-ordinal-number");
 // Then the function should return a string by appending "st" to the number.
 test("should append 'st' for numbers ending with 1, except those ending with 11", () => {
   expect(getOrdinalNumber(1)).toEqual("1st");
-  expect(getOrdinalNumber(21)).toEqual("21st");
+  expect(getOrdinalNumber(31)).toEqual("31st");
   expect(getOrdinalNumber(131)).toEqual("131st");
 });
+ test(`should append 'nd' for numbers ending with 2 except those ending with 12 `, () => {
+  expect(getOrdinalNumber(2)).toEqual("2nd");
+  expect(getOrdinalNumber(22)).toEqual("22nd");
+  expect(getOrdinalNumber(132)).toEqual("132nd");   
+});
+
+ test(`should append 'rd' for numbers ending with 3 except those ending with 13 `, () => {
+  expect(getOrdinalNumber(3)).toEqual("3rd");
+  expect(getOrdinalNumber(23)).toEqual("23rd");
+  expect(getOrdinalNumber(143)).toEqual("143rd");
+});
+

Sprint-3/3-dead-code/exercise-1.js

@@ -5,9 +5,8 @@ let testName = "Jerry";
 const greeting = "hello";
 
 function sayHello(greeting, name) {
-  const greetingStr = greeting + ", " + name + "!";
   return `${greeting}, ${name}!`;
-  console.log(greetingStr);
+
 }
 
 testName = "Aman";

Sprint-3/3-dead-code/exercise-2.js

@@ -2,12 +2,10 @@
 // The countAndCapitalisePets function should continue to work for any reasonable input it's given, and you shouldn't modify the pets variable.
 
 const pets = ["parrot", "hamster", "horse", "dog", "hamster", "cat", "hamster"];
-const capitalisedPets = pets.map((pet) => pet.toUpperCase());
+
 const petsStartingWithH = pets.filter((pet) => pet[0] === "h");
 
-function logPets(petsArr) {
-  petsArr.forEach((pet) => console.log(pet));
-}
+
 
 function countAndCapitalisePets(petsArr) {
   const petCount = {};

Sprint-3/4-stretch/find.js

@@ -20,6 +20,24 @@ console.log(find("code your future", "z"));
 // Pay particular attention to the following:
 
 // a) How the index variable updates during the call to find
+// the index variable starts at 0 and is incremented by 1 after each iteration of the while loop.
+
 // b) What is the if statement used to check
+// the if statement is used to check if the character at the current index of the string is equal to the character we are searching for.
+// if the condition is true ,it will return the index of the character in the string. '
+// if the condition is false, it will continue to the next iteration of the loop until it finds the character or reaches the end of the string.
+
 // c) Why is index++ being used?
+/*
+ the index++ is used to increment the index variable by 1 after each iteration of the loop. 
+This allows the loop to move to the next character in the string for the next iteration. Without this increment, 
+the loop would get stuck on the same character and could potentially run indefinitely if the condition is never met.
+*/
+
 // d) What is the condition index < str.length used for?
+/*
+the index < str.length  condition is used to ensure that the loop continues to iterate through the string until it reaches the end.
+the index variable is used to keep track of the current position in the string, and the loop will continue as long as index is less than the length of the string. 
+Once index reaches the length of the string, 
+ it means we have checked all characters in the string, and if we haven't found the character we're looking for, we return -1 to indicate that it was not found.
+ */

Sprint-3/4-stretch/password-validator.js

@@ -3,4 +3,13 @@ function passwordValidator(password) {
 }
 
 
+module.exports = passwordValidator;
+ function passwordValidator(password) {
+    if (password.length < 5){
+         return false;
+    } else if (password.length >= 5 ){
+        return true;
+    }
+}
+
 module.exports = passwordValidator;