CYF ITP South Africa - Cape Town | Emmanuel Siziba | Module-Structuring-and-Testing-Data | Week 3

Sprint-3/implement/get-angle-type.js

@@ -1,4 +1,4 @@
-// Implement a function getAngleType
+i// Implement a function getAngleType
 
 // Acceptance criteria:
 
@@ -25,3 +25,31 @@
 // Identify Reflex Angles:
 // When the angle is greater than 180 degrees and less than 360 degrees,
 // Then the function should return "Reflex angle"
+
+
+function getAngleType(angle){
+    if(angle === 90){
+      return "Right angle";
+    }
+
+    if(angle  < 90){
+      return "Acute angle";
+    }
+    if (angle < 180){
+      return "Obtuse angle";
+    }
+
+    if(angle === 180){
+      return "Straight angle"
+    }
+
+     if(angle > 180 && angle < 360){
+      return "Reflex angle" 
+    }
+
+    else {
+        return "Invalid angle"
+    }
+  }
+   module.exports = getAngleType;
+

Sprint-3/implement/get-angle-type.test.js

@@ -0,0 +1,23 @@
+const getAngleType = require('./get-angle-type')
+
+test('Returns "Right angle" when the angle is exactly 90 degrees', () => {
+    expect(getAngleType(90)).toBe('Right angle');
+  });
+
+test('Returns "Acute" when the angle is less than 90 degrees', () => {
+expect(getAngleType(45)).toBe('Acute angle');
+});
+
+test('Returns "Obtuse angle" when the angle is greater than 90 degrees but less than 180 degrees', () => {
+expect(getAngleType(120)).toBe('Obtuse angle');
+});
+
+
+test('Returns "Straight angle" when the angle is exactly 180 degrees', () => {
+    expect(getAngleType(180)).toBe('Straight angle');
+  });
+
+
+test('Returns "Reflex angle" when the angle is greater than 180 degrees but less than 360 degrees', () => {
+  expect(getAngleType(220)).toBe('Reflex angle');
+});

Sprint-3/implement/get-card-value.js

@@ -29,3 +29,23 @@
 // Given a card with an invalid rank (neither a number nor a recognized face card),
 // When the function is called with such a card,
 // Then it should throw an error indicating "Invalid card rank."
+ const validRanks = new Set(['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']);
+
+function getCardValue(rankString) {
+  const rank = rankString.substring(0, rankString.length - 1);
+
+  if (validRanks.has(rank)) {
+    if (rank === 'A') {
+      return 11;
+    } else if (rank === 'J' || rank === 'Q' || rank === 'K') {
+      return 10;
+    } else {
+      return parseInt(rank);
+    }
+  } else {
+    throw new Error(`Invalid card rank: ${rankString}`);
+  }
+}
+
+  module.exports = getCardValue;
+

Sprint-3/implement/get-card-value.test.js

@@ -0,0 +1,26 @@
+const getCardValue = require('./get-card-value')
+
+test('getCardValue returns 11 for Ace', () => {
+    expect(getCardValue('A♠')).toBe(11);
+  });
+
+
+test('getCardValue returns 10 for J, Q or K', () => {
+    expect(getCardValue('J♠')).toBe(10);
+    expect(getCardValue('Q♠')).toBe(10);
+    expect(getCardValue('K♠')).toBe(10);
+  });
+
+
+test('getCardValue returns parseInt(rank) for 2 & 9', () => {
+  expect(getCardValue('2')).toBe(parseInt('2'));
+  expect(getCardValue('9')).toBe(parseInt('9'));
+});
+
+test('getCardValue throws error for invalid rank', () => {
+  expect(() => getCardValue('A♠♠')).toThrow('Invalid card rank.');
+  expect(() => getCardValue('Q$')).toThrow('Invalid card rank.');
+  expect(() => getCardValue('K&')).toThrow('Invalid card rank.');
+
+
+});

Sprint-3/implement/is-proper-fraction.js

@@ -32,3 +32,13 @@
 // target output: false
 // Explanation: The fraction 3/3 is not a proper fraction because the numerator is equal to the denominator. The function should return false.
 // These acceptance criteria cover a range of scenarios to ensure that the isProperFraction function handles both proper and improper fractions correctly and handles potential errors such as a zero denominator.
+
+ function isProperFraction(numerator, denominator) {
+  if (denominator === 0) {
+    throw new Error("Denominator cannot be zero");
+  }
+  return Math.abs(numerator) < denominator;
+}
+
+module.exports = isProperFraction;
+

Sprint-3/implement/is-proper-fraction.test.js

@@ -0,0 +1,22 @@
+const isProperFraction = require('./is-proper-fraction');
+
+test('return true for a proper function', () => {
+  expect(isProperFraction(2, 3)).toBe(true);
+  });
+
+test('returns an error for an improper function', () => {
+  expect(() => isProperFraction(3, 0)).toThrow('Denominator cannot be zero');
+});
+
+test('return false for a improper function', () => {
+expect(isProperFraction(5, 2)).toBe(false);
+});
+
+test('return true for a proper function', () => {
+ expect(isProperFraction(4, 7)).toBe(true);
+});
+
+test('return false for a improper function', () => {
+ expect(isProperFraction(3, 3)).toBe(false);
+});
+

Sprint-3/implement/is-valid-triangle.js

@@ -33,3 +33,14 @@
 // Then it should return true because the input forms a valid triangle.
 
 // This specification outlines the behavior of the isValidTriangle function for different input scenarios, ensuring it properly checks for invalid side lengths and whether they form a valid triangle according to the Triangle Inequality Theorem.
+function isValidTriangle(a, b, c) {
+    if (a <= 0 || b <= 0 || c <= 0) {
+      return false;
+  } 
+    else if ((a + b > c) && (a + c > b) && (b + c > a)) {
+      return true;
+  } 
+    return false;
+  }
+
+  module.exports = isValidTriangle;

Sprint-3/implement/is-valid-triangle.test.js

@@ -0,0 +1,22 @@
+const isValidTriangle = require('./is-valid-triangle');
+
+test('validates a triangle where the sum of any two sides is always greater than the third side', () => {
+
+    expect(isValidTriangle('a, b, c')).toBe(true);
+});
+
+//test('returns false when the sum of any two side lengths is less than or equal to the length of the third side', () => {
+
+//    expect(isValidTriangle('a, b, c')).toBe(false);
+//});
+
+//test('returns false when the sides are less than or equal to zero', () => {
+
+//   expect(isValidTriangle('a, b, c')).toBe(false);
+//});
+
+//test('returns true when the sides are the sum of any two sides is greater than the third side', () => {
+
+// expect(isValidTriangle('a, b, c')).toBe(true);
+//});
+// I can not seem to make this test pass

Sprint-3/implement/rotate-char.js

@@ -16,28 +16,41 @@
 // Given a lowercase letter character and a positive integer shift,
 // When the function is called with these inputs,
 // Then it should rotate the lowercase letter by shift positions within the lowercase alphabet, wrapping around if necessary, and return the rotated lowercase letter as a string.
-console.log(rotateCharacter("a", 3)); // Output: "d"
-console.log(rotateCharacter("f", 1)); // Output: "g"
+//console.log(rotateCharacter("a", 3)); // Output: "d"
+//console.log(rotateCharacter("f", 1)); // Output: "g"
 
 // Scenario: Rotate Uppercase Letters:
 // Given an uppercase letter character and a positive integer shift,
 // When the function is called with these inputs,
 // Then it should rotate the uppercase letter by shift positions within the uppercase alphabet, wrapping around if necessary, and return the rotated uppercase letter as a string.
-console.log(rotateCharacter("A", 3)); // Output: "D"
-console.log(rotateCharacter("F", 1)); // Output: "G"
+//console.log(rotateCharacter("A", 3)); // Output: "D"
+//console.log(rotateCharacter("F", 1)); // Output: "G"
 
 // Scenario: Leave Non-Letter Characters Unchanged:
 // Given a character that is not a letter (neither uppercase nor lowercase) and any positive or negative shift value,
 // When the function is called with these inputs,
 // Then it should return the character unchanged.
 // This specification outlines the behavior of the rotateCharacter function for different input scenarios, including valid and invalid characters, and defines the expected output or action for each case.
-console.log(rotateCharacter("7", 5)); // Output: "7" (unchanged, not a letter)
+//console.log(rotateCharacter("7", 5)); // Output: "7" (unchanged, not a letter)
 
 // Scenario: Shifting a Character with Wraparound
 // Given a character char within the lowercase alphabet range (e.g., 'z') or the uppercase alphabet range (e.g., 'Z'),
 // And a positive integer shift that causes the character to wrap around the alphabet when rotated (e.g., a shift of 3 for 'z' or 'Z'),
 // When the rotateCharacter function is called with char and shift as inputs,
 // Then it should correctly rotate the character by shift positions within the alphabet while handling the wraparound,
 // And the function should return the rotated character as a string (e.g., 'z' rotated by 3 should become 'c', 'Z' rotated by 3 should become 'C').
-console.log(rotateCharacter("z", 1)); // Output: "a" (preserves case, but wraps around)
-console.log(rotateCharacter("Y", 2)); // Output: "A" (preserves case, but wraps around)
+//console.log(rotateCharacter("z", 1)); // Output: "a" (preserves case, but wraps around)
+//console.log(rotateCharacter("Y", 2)); // Output: "A" (preserves case, but wraps around)
+
+
+
+function rotateCharacter(char, shift) {
+    const isLowercase = char.toLowerCase() === char;
+    const baseCode = isLowercase ? 'a'.charCodeAt(0) : 'A'.charCodeAt(0);
+    const charCode = char.charCodeAt(0);
+
+    let rotatedCode = ((charCode - baseCode + shift) % 26) + baseCode;
+    return String.fromCharCode(rotatedCode);
+}
+
+module.exports = rotateCharacter;

Sprint-3/implement/rotate-char.test.js

@@ -0,0 +1,19 @@
+const rotateCharacter = require('./rotate-char');
+
+test('rotates a lowercase letter by the given shift', () => {
+  expect(rotateCharacter('a', 3)).toBe('d');
+});
+
+test('rotates a lowercase letter with negative shift', () => {
+  expect(rotateCharacter('d', -3)).toBe('a');
+});
+
+test('rotates an uppercase letter by the given shift', () => {
+  expect(rotateCharacter('A', 3)).toBe('D');
+});
+
+test('rotates an uppercase letter with negative shift', () => {
+  expect(rotateCharacter('D', -3)).toBe('A');
+});
+
+

Sprint-3/revise/implement/card-validator.md

@@ -33,3 +33,20 @@ These are the requirements your project needs to fulfill:
 - Return a boolean from the function to indicate whether the credit card number is valid.
 
 Good luck!
+
+
+//Answer: Breakdown
+touch command to create file cardValidator.js
+define a function cardValidator(cardNumber16digits){}
+// this function checks if the card number entered by a user is valid.
+// a valid card number has the following parameters: 16 digits, ends in even number so use %2 if ==0 then even, if cardNumber sum > 16 card is valid.
+function ends in return boolean if card is valid(true) or invalid(false) */
+
+
+
+function cardValidator(cardNumber){
+    // this function checks if the card number entered by a user is valid.
+    // a valid card number has the following parameters: 16 digits, ends in even number so use %2 if ==0 then even, if cardNumber sum > 16 card is valid.
+    // a conditional statement to say if the cardNumber is true or false
+    return validCard //this is a true or false to show if the card is valid
+}

Sprint-3/revise/implement/count.js

@@ -0,0 +1,11 @@
+function countChar(str, char) {
+    let count = 0;
+    for (let i = 0; i < str.length; i++){
+        if (str[i] === char) {
+            count++;
+        }
+    }
+    return count;
+}
+
+ module.exports = countChar;

Sprint-3/revise/implement/count.test.js

@@ -15,3 +15,15 @@
 // And a character char that does not exist within the case-sensitive str,
 // When the function is called with these inputs,
 // Then it should return 0, indicating that no occurrences of the char were found in the case-sensitive str.
+
+const countChar = require('./count');
+
+test('counts muiltiple characters occurrences of a character in a string', () => {
+    expect(countChar('aaaaa', 'a')).toBe(5); 
+  });
+
+test('counts overlapping occurrences of a character in a string', () => {
+    expect(countChar('', 'a')).toBe(0); 
+  });
+
+

Sprint-3/revise/implement/get-ordinal-number.js

@@ -0,0 +1,12 @@
+function getOrdinalNumber(number) {
+    if (number === 1) {
+      return number + "st";
+    } else if (number === 2) {
+      return number + "nd";
+    } else if (number === 3) {
+      return number + "rd";
+    }  
+  }
+
+  module.exports = getOrdinalNumber;
+

Sprint-3/revise/implement/get-ordinal-number.test.js

@@ -1,4 +1,26 @@
 // In this week's prep, we started implementing getOrdinalNumber
 
-// continue testing and implementing getOrdinalNumber for additional cases
+//Continue testing and implementing getOrdinalNumber for additional cases
 // Write your tests using Jest - remember to run your tests often for continual feedback
+
+const getOrdinalNumber = require('./get-ordinal-number');
+
+test("Expect 'st' as suffix when the last digit is 1 but the last two digits are not 11, 12, or 13", () => {
+  expect(getOrdinalNumber(1)).toBe("1st");
+  expect(getOrdinalNumber(21)).toBe("21st");
+});
+
+test("Expect 'nd' as suffix when the last digit is 2 but the last two digits are not 12", () => {
+  expect(getOrdinalNumber(2)).toBe("2nd");
+  expect(getOrdinalNumber(22)).toBe("22nd");   
+});
+
+test("Expect 'rd' as suffix when the last digit is 3 but the last two digits are not 13", () => {
+  expect(getOrdinalNumber(3)).toBe("3rd");
+  expect(getOrdinalNumber(23)).toBe("23rd");
+});
+
+test("Expect 'th' as suffix for all other cases", () => {
+  expect(getOrdinalNumber(4)).toBe("4th");
+  expect(getOrdinalNumber(11)).toBe("11th");
+});

Sprint-3/revise/implement/is-prime.js

@@ -0,0 +1,16 @@
+ function isPrime(num) {
+
+  if (num <= 1) return false;
+  if (num === 2) return true;
+
+  const sqrtNum = Math.sqrt(num);
+  for (let i = 3; i <= sqrtNum; i += 2) {
+    if (num % i === 0) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+module.exports = isPrime;

Sprint-3/revise/implement/is-prime.test.js

@@ -1,3 +1,17 @@
 // Given a positive integer num,
 // When the isPrime function is called with num as input,
 // Then it should check if the num is prime
+
+const isPrime = require('./is-prime');
+
+test('checks if 7 is a prime number', () => {
+    expect(isPrime(7)).toBe(true); 
+    expect(isPrime(0)).toBe(false); 
+    expect(isPrime(1)).toBe(false);  
+    expect(isPrime(2)).toBe(true);  
+    expect(isPrime(3)).toBe(true);   
+    expect(isPrime(5)).toBe(true);  
+    expect(isPrime(6)).toBe(false);  
+    expect(isPrime(23)).toBe(true); 
+    expect(isPrime(24)).toBe(false); 
+});