Brussels | ITP-2025-1 | Pinky Benitez | Sprint 11 | All exercises from UNIT TESTING and code reading from Debugging

challenges/unit-testing/katas-tdd/calculator/add.test.js

@@ -0,0 +1,27 @@
+const add = require('./script');  
+
+test("empty string returns 0", () => {
+  expect(add("")).toBe(0);
+});
+
+test("single number returns the number", () => {
+  expect(add("5")).toBe(5);
+});
+
+test("two numbers return their sum", () => {
+  expect(add("3,6")).toBe(9);
+});
+
+test("multiple numbers return their sum", () => {
+  expect(add("1,2,3,4")).toBe(10);  // 1+2+3+4 = 10
+});
+
+test("numbers greater than 1000 are ignored", () => {
+  expect(add("2,1001")).toBe(2);  // 1001 is ignored
+  expect(add("1000,1001")).toBe(1000);  // 1001 is ignored
+});
+
+test("negative numbers throw an error", () => {
+  expect(() => add("1,4,-1")).toThrow("negatives not allowed: -1");
+  expect(() => add("-1,-2,-3")).toThrow("negatives not allowed: -1, -2, -3");
+});

challenges/unit-testing/katas-tdd/calculator/script.js

@@ -0,0 +1,22 @@
+function add(numbers) {
+  if (numbers === "") {
+    return 0;
+  }
+  const negatives = [];
+  const sum = numbers.split(',').reduce((sum, num) => {
+    const number = parseInt(num);
+    if (number < 0) {
+      negatives.push(number);
+    } else if (number <= 1000) {
+      sum += number;
+    }
+    return sum;
+  }, 0);
+
+  if (negatives.length > 0) {
+    throw new Error(`negatives not allowed: ${negatives.join(", ")}`);
+  }
+
+  return sum;
+}
+module.exports = add;

challenges/unit-testing/katas-tdd/calculator/test.js

@@ -0,0 +1,27 @@
+const add = require('./script');  
+
+test("empty string returns 0", () => {
+  expect(add("")).toBe(0);
+});
+
+test("single number returns the number", () => {
+  expect(add("5")).toBe(5);
+});
+
+test("two numbers return their sum", () => {
+  expect(add("3,6")).toBe(9);
+});
+
+test("multiple numbers return their sum", () => {
+  expect(add("1,2,3,4")).toBe(10);  // 1+2+3+4 = 10
+});
+
+test("numbers greater than 1000 are ignored", () => {
+  expect(add("2,1001")).toBe(2);  // 1001 is ignored
+  expect(add("1000,1001")).toBe(1000);  // 1001 is ignored
+});
+
+test("negative numbers throw an error", () => {
+  expect(() => add("1,4,-1")).toThrow("negatives not allowed: -1");
+  expect(() => add("-1,-2,-3")).toThrow("negatives not allowed: -1, -2, -3");
+});

challenges/unit-testing/katas-tdd/password-verifier/passverifier.test.js

@@ -0,0 +1,20 @@
+const verify = require('./script');  
+test('password should be rejected if it is less than 8 characters', () => {
+  expect(verify('short')).toBe('Password rejected');
+});
+
+test('password should be rejected if it is null', () => {
+  expect(verify(null)).toBe('Password rejected');
+});
+
+test('password should be rejected if it has no uppercase letter', () => {
+  expect(verify('password1')).toBe('Password rejected');  
+});
+
+test('password should be rejected if it has no number', () => {
+  expect(verify('Password')).toBe('Password rejected');
+});
+
+test('password should be accepted if it has at least 8 characters, 1 uppercase letter, and 1 number', () => {
+  expect(verify('Password1')).toBe('Password accepted');
+});

challenges/unit-testing/katas-tdd/password-verifier/script.js

@@ -0,0 +1,37 @@
+function verify(password) {
+
+  if (password === null || password.length < 8) {
+    return 'Password rejected';
+  }
+
+
+  let hasUppercase = false;
+  for (let i = 0; i < password.length; i++) {
+    if (password[i] === password[i].toUpperCase() && /[A-Za-z]/.test(password[i])) {
+      hasUppercase = true;
+      break;
+    }
+  }
+
+  if (!hasUppercase) {
+    return 'Password rejected';
+  }
+
+
+  let hasNumber = false;
+  for (let i = 0; i < password.length; i++) {
+    if (/[0-9]/.test(password[i])) {
+      hasNumber = true;
+      break;
+    }
+  }
+
+  if (!hasNumber) {
+    return 'Password rejected';
+  }
+
+
+  return 'Password accepted';
+}
+
+module.exports = verify; 

challenges/unit-testing/katas-tdd/roman-numerals/convert-to-new-roman.js

@@ -1,3 +1,31 @@
-function convertToNewRoman(n) {}
+function convertToNewRoman(n) {
+  let result = "";
+
+
+  const romanNumerals = [
+    { value: 1000, symbol: "M" },
+    { value: 900, symbol: "CM" },
+    { value: 500, symbol: "D" },
+    { value: 400, symbol: "CD" },
+    { value: 100, symbol: "C" },
+    { value: 90, symbol: "XC" },
+    { value: 50, symbol: "L" },
+    { value: 40, symbol: "XL" },
+    { value: 10, symbol: "X" },
+    { value: 9, symbol: "IX" },
+    { value: 5, symbol: "V" },
+    { value: 4, symbol: "IV" },
+    { value: 1, symbol: "I" }
+  ];
+
+  for (let i = 0; i < romanNumerals.length; i++) {
+    while (n >= romanNumerals[i].value) {
+      result += romanNumerals[i].symbol;
+      n -= romanNumerals[i].value;
+    }
+  }
+
+  return result;
+}
 
 module.exports = convertToNewRoman;

challenges/unit-testing/katas-tdd/roman-numerals/convert-to-new-roman.test.js

@@ -1,7 +1,29 @@
 let convertToNewRoman = require("./convert-to-new-roman");
 
 test("returns I if passed 1 as an argument", function () {
-  // Arrange
-  // Act
-  // Assert
+  expect(convertToNewRoman(1)).toBe("I");
+});
+
+test("returns IV if passed 4 as an argument", function () {
+  expect(convertToNewRoman(4)).toBe("IV");
+});
+
+test("returns IX if passed 9 as an argument", function () {
+  expect(convertToNewRoman(9)).toBe("IX");
+});
+
+test("returns XIV if passed 14 as an argument", function () {
+  expect(convertToNewRoman(14)).toBe("XIV");
+});
+
+test("returns XLIV if passed 44 as an argument", function () {
+  expect(convertToNewRoman(44)).toBe("XLIV");
+});
+
+test("returns XCIX if passed 99 as an argument", function () {
+  expect(convertToNewRoman(99)).toBe("XCIX");
+});
+
+test("returns CMXLIV if passed 944 as an argument", function () {
+  expect(convertToNewRoman(944)).toBe("CMXLIV");
 });

challenges/unit-testing/katas-tdd/roman-numerals/convert-to-old-roman.js

@@ -1,3 +1,26 @@
-function convertToOldRoman(n) {}
+function convertToOldRoman(n) {
+  let result = "";
+
+
+  const romanNumerals = [
+    { value: 1000, symbol: "M" },
+    { value: 500, symbol: "D" },
+    { value: 100, symbol: "C" },
+    { value: 50, symbol: "L" },
+    { value: 10, symbol: "X" },
+    { value: 5, symbol: "V" },
+    { value: 1, symbol: "I" }
+  ];
+
+
+  for (let i = 0; i < romanNumerals.length; i++) {
+    while (n >= romanNumerals[i].value) {
+      result += romanNumerals[i].symbol;
+      n -= romanNumerals[i].value;
+    }
+  }
+
+  return result;
+}
 
 module.exports = convertToOldRoman;

challenges/unit-testing/katas-tdd/roman-numerals/convert-to-old-roman.test.js

@@ -1,7 +1,26 @@
 let convertToOldRoman = require("./convert-to-old-roman");
 
 test("returns I if passed 1 as an argument", function () {
-  // Arrange
-  // Act
-  // Assert
+  expect(convertToOldRoman(1)).toBe("I");
+});
+
+test("returns III if passed 3 as an argument", function () {
+  expect(convertToOldRoman(3)).toBe("III");
+});
+
+test("returns VII if passed 7 as an argument", function () {
+  expect(convertToOldRoman(7)).toBe("VII"); 
+});
+
+test("returns XV if passed 15 as an argument", function () {
+  expect(convertToOldRoman(15)).toBe("XV");
+});
+
+test("returns XVIII if passed 18 as an argument", function () {
+  expect(convertToOldRoman(18)).toBe("XVIII"); 
+});
+
+
+test("returns XXII if passed 22 as an argument", function () {
+  expect(convertToOldRoman(22)).toBe("XXII");
 });