CYF-ITP - South Africa | Simphiwe Mabuya | Structuring-and-Testing-Data | Sprint-3

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

@@ -6,6 +6,21 @@
 // When the function getAngleType is called with this angle,
 // Then it should:
 
+function getAngleType(degrees) {
+    if (degrees === 90) return "Right angle";
+    if (degrees < 90) return "Acute angle";
+    if (degrees > 90 && degrees < 180) return "Obtuse angle";
+    if (degrees === 180) return "Straight angle";
+    if (degrees > 180 && degrees < 360) return "Reflex angle";
+    return "Invalid angle";
+}
+
+module.exports = getAngleType; 
+
+console.log(getAngleType(359));
+
+
+
 // Identify Right Angles:
 // When the angle is exactly 90 degrees,
 // Then the function should return "Right angle"

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

@@ -0,0 +1,30 @@
+
+const getAngleType = require("./get-angle-type");
+
+
+test("Checks for Right Angle for when the angle is 90 degrees", () => {
+    expect(getAngleType(90)).toEqual("Right angle");
+});
+
+
+test("Checks for Acute angle, when the angle < 90 degrees", () => {
+    expect(getAngleType(45)).toEqual("Acute angle");
+});
+
+
+test("Checks for Obtuse angle, when the angle > 90 and angle < 180 degrees", () => {
+    expect(getAngleType(145)).toEqual("Obtuse angle");
+});
+
+
+test("Checks for Straight angle, when the angle is exactly 180 degrees", () => {
+    expect(getAngleType(180)).toEqual("Straight angle");
+});
+
+
+test("Expect 'Reflect angle' when 180 < angle < 360", () => {
+    expect(getAngleType(192)).toEqual("Reflex angle");
+});
+
+
+

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

@@ -2,6 +2,37 @@
 
 // You will need to implement a function getCardValue
 
+function getCardValue(cardRank){
+
+    if(cardRank === "10"){
+        return 10;
+    }
+
+    if(/^0\d/.test(cardRank) || /\.\d/.test(cardRank)){
+        return "Invalid card rank";
+    }
+
+    cardRank = cardRank.slice(0, 2) === "10" ? "10" : cardRank.slice(0, 1);
+
+    if(cardRank ==="A"){
+        return 11;
+    }else if(cardRank === "J" || cardRank === "K" || cardRank === "Q"){
+        return 10;
+    }
+
+    const numericalValue = parseInt(cardRank, 10);
+    if(numericalValue >= 2 && numericalValue <= 10){
+        return numericalValue;
+    }else {
+        return 'Invalid card rank'
+    }
+}
+module.exports = getCardValue;
+
+
+//testGetCardValue();
+console.log(getCardValue("2.1♣"));
+
 // You need to write assertions for your function to check it works in different cases
 
 // Acceptance criteria:

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

@@ -0,0 +1,26 @@
+const getCardValue = require("./get-card-value");
+
+
+test("Checks if cardRank is 'A♠' then returns 11 ", () => {
+    expect(getCardValue("A♠")).toEqual(11);
+});
+
+test("Checks if cardRank is 'J♦' then returns 10 ", () => {
+    expect(getCardValue("J♦")).toEqual(10);
+});
+
+test("Checks if cardRank is 'K♥' then returns 10 ", () => {
+    expect(getCardValue("K♥")).toEqual(10);
+});
+
+test("Checks if cardRank is 'Q♣' then returns 10 ", () => {
+    expect(getCardValue("Q♣")).toEqual(10);
+});
+
+test("Checks if cardRank is '8' then returns 8 ", () => {
+    expect(getCardValue("8")).toEqual(8);
+});
+
+test("Checks if cardRank is '2.1' then returns 'Invalid card rank", () => {
+    expect(getCardValue("2.1♣")).toEqual("Invalid card rank");
+});

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

@@ -5,6 +5,22 @@
 // Fractions: https://www.bbc.co.uk/bitesize/topics/zt9n6g8/articles/zjxpp4j
 // Written here like this: 1/2 == Numerator/Denominator
 
+function isProperFraction(num,den){
+
+    if(den === 0){
+        throw new Error('Denominator must be a positive or negative number');
+    }
+        den = Math.abs(den);
+
+    return Math.abs(num) < den;
+
+}
+
+module.exports = isProperFraction;
+
+
+console.log(isProperFraction(-4,-7))
+
 // Acceptance criteria:
 
 // Proper Fraction check:

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

@@ -0,0 +1,23 @@
+const isProperFraction = require("./is-proper-fraction");
+
+
+test("Checks if the fraction is a Proper fraction (2/3) or (-4/-7) then return true", () => {
+    expect(isProperFraction(1, 2)).toEqual(true);
+    expect(isProperFraction(-4,-7)).toEqual(true);
+});
+
+test("Checks if the fraction is a Negative fraction (-4/7) then return true", () => {
+    expect(isProperFraction(-4, 7)).toEqual(true);
+});
+
+test("Checks if the fraction is an Improper fraction (5/3) then return false", () => {
+    expect(isProperFraction(5, 3)).toEqual(false);
+});
+
+test("Checks if the Numerator === Denominator (3/3) then return false", () => {
+    expect(isProperFraction(3, 3)).toEqual(false);
+});
+
+test("Throws an error when the denominator is zero", () => {
+    expect(() => isProperFraction(3, 0)).toThrow("Denominator must be a positive or negative number");
+});

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

@@ -11,6 +11,19 @@
 // It's also true that b + c > a
 // It's also true that a + c > b
 
+function isValidTriangle(a,b,c){
+
+    if ( (a + b > c) && (a + c > b) && (b + c > a)){
+        return true;
+    }else {
+        return false;
+    }
+}
+
+module.exports = isValidTriangle;
+
+console.log(isValidTriangle(3,2,4));
+
 // In our function isValidTriangle which takes as parameters the lengths of three sides, we need to invalidate any triangle where the sum of any two sides is less than or equal to the length of the third side.
 // and we need to validate any triangle where the sum of any two sides is greater than the length of the third side.
 

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

@@ -0,0 +1,13 @@
+const isValidTriangle = require("./is-valid-triangle");
+
+test("Checks for Valid Triangle where the sum is (a + b > c)", () => {
+    expect(isValidTriangle(3, 5, 4)).toEqual(true);
+});
+
+test("Checks for Invalid Triangle when any of the sides are less than or equal to zero ", () => {
+    expect(isValidTriangle(0, 2, 4)).toEqual(false);
+});
+
+test("Checks for Invalid Triangle, where the sum is (b + c <= a)", () => {
+    expect(isValidTriangle(2, 2, 4)).toEqual(false);
+});

Sprint-3/implement/rotate-char.js → Sprint-3/implement/rotate-character.js

@@ -6,6 +6,38 @@
 // This function is commonly used for text encryption and decryption,
 // where shifting characters by a certain value can obscure their meaning or reveal hidden messages.
 
+function rotateCharacter(character, shift) {
+    let startCode;
+
+    // Checks if the character is a letter
+    if (character >= 'A' && character <= 'Z') {
+        // Uppercase letter
+        startCode = 'A'.charCodeAt(0);
+    } else if (character >= 'a' && character <= 'z') {
+        // Lowercase letter
+        startCode = 'a'.charCodeAt(0);
+    } else {
+        // Not a letter, return it unchanged
+        return character;
+    }
+
+    // Gets the character's position in the alphabet
+    const charPosition = character.charCodeAt(0) - startCode;
+
+    // Rotates the position within the alphabet (wrap around using %)
+    const newPosition = (charPosition + shift) % 26;
+
+    // Handles negative shift values to wrap correctly
+    const wrappedPosition = newPosition < 0 ? newPosition + 26 : newPosition;
+
+    // Converts the new position back to a character
+    const rotatedChar = String.fromCharCode(startCode + wrappedPosition);
+
+    return rotatedChar;
+}
+
+module.exports = rotateCharacter;
+
 // Acceptance criteria:
 
 // Given a character and a shift value,

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

@@ -0,0 +1,19 @@
+const rotateCharacter = require("./rotate-character");
+
+test("Checks for Rotate Lowercase Letters", () => {
+    expect(rotateCharacter("a", 3)).toEqual("d");
+});
+
+test("Checks for Rotate Uppercase Letters", () => {
+    expect(rotateCharacter("F", 1)).toEqual("G");
+});
+
+test("Checks for where Non-Letter Characters are left Unchanged", () => {
+    expect(rotateCharacter(7, 5)).toEqual(7);
+});
+
+test("Checks if a Characters shift with Wraparound", () => {
+    expect(rotateCharacter("Y", 2)).toEqual("A");
+});
+
+