Enhance countChar function with improved error handling and refactor tests for clarity

Author: Baba05206

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

@@ -7,36 +7,23 @@ function countChar(stringOfCharacters, findCharacter) {
     return "Error: The string cannot be empty.";
   }
 
-  const chars = [...stringOfCharacters];
-  const findChars = [...findCharacter];
+  if (findCharacter == null) {
+    return "Error: The character to count must be a single character.";
+  }
 
-  if (!findCharacter || findChars.length !== 1) {
+  const findChars = [...findCharacter];
+  if (findChars.length !== 1) {
     return "Error: The character to count must be a single character.";
   }
 
   let count = 0;
-  for (let ch of chars) {
+  for (let ch of stringOfCharacters) {
     if (ch === findCharacter) count++;
   }
 
   return count;
 }
 
-// Examples
-console.log(countChar("hello", "l")); // Expected: 2
-console.log(countChar("javascript", "a")); // Expected: 2
-console.log(countChar("hello", "z")); // Expected: 0
-console.log(countChar("null", "")); // Expected: "Error: The character to count must be a single character."
-console.log(countChar("", "a")); // Expected: "Error: The string cannot be empty."
-console.log(countChar("hello", "ll")); // Expected: "Error: The character to count must be a single character."
-console.log(countChar("hipopotamos' make wonderful pets", "o")); // Expected: 3
-console.log(countChar("hipopotamos", "p")); // Expected: 1
-console.log(countChar("hipopotamos' are a friendly animal", "t")); // Expected: 1
-console.log(countChar("hipopotamos", "x")); // Expected: 0
-console.log(countChar("Pneumonoultramicroscopicsilicovolcanoconiosis", "i")); // Expected: 6
-console.log(countChar("null", "")); // Expected: "Error: The character to count must be a single character."
-console.log(countChar("", "a")); // Expected: "Error: The string cannot be empty."
-console.log(countChar("hello", "ll")); // Expected: "Error: The character to count must be a single character."
-console.log(countChar(null, "a")); // Expected: "Error: The input string cannot be null or undefined."
-
 module.exports = countChar;
+
+// implement a function countChar that counts the number of times a character occurs in a string

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

@@ -4,117 +4,66 @@ const countChar = require("./count");
 // When the countChar function is called with these inputs,
 // Then it should:
 
-// Scenario: Multiple Occurrences
-// Given the input string str,
-// And a character char that may occur multiple times with overlaps within str (e.g., 'a' in 'aaaaa'),
-// When the function is called with these inputs,
-// Then it should correctly count overlapping occurrences of char (e.g., 'a' appears five times in 'aaaaa').
-test("should count multiple occurrences of a character", () => {
-  const str = "aaaaa";
-  const char = "a";
-  const count = countChar(str, char);
-  expect(count).toEqual(5);
+const countChar = require("./count");
+
+// Grouped tests for standard character counting
+test.each([
+  ["a", "aaaaa", 5],
+  ["l", "hello", 2],
+  ["a", "javascript", 2],
+  ["z", "hello", 0],
+  ["h", "hello", 1],
+  ["o", "hipopotamos' make wonderful pets", 3],
+  ["p", "hipopotamos", 1],
+  ["t", "hipopotamos' are a friendly animal", 1],
+  ["x", "hipopotamos", 0],
+  ["i", "Pneumonoultramicroscopicsilicovolcanoconiosis", 6],
+])("should count occurrences of character '%s' in string '%s'", (char, str, expected) => {
+  expect(countChar(str, char)).toEqual(expected);
 });
 
-// Scenario: No Occurrences
-// Given the input string str,
-// 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.
-test("should return 0 if the character does not exist in the string", () => {
-  expect(countChar("hello", "z")).toEqual(0);
+// Edge case: empty string
+test("should return error if the string is empty", () => {
+  expect(countChar("", "a")).toEqual("Error: The string cannot be empty.");
 });
 
-// Scenario: Single Occurrence
-// Given the input string str,
-// And a character char that occurs exactly once in str,
-// When the function is called with these inputs,
-// Then it should return 1, indicating one occurrence of char in str.
-test("should count a single occurrence of a character", () => {
-  expect(countChar("hello", "h")).toEqual(1);
+// Edge case: null or undefined string
+test("should return error if the string is null or undefined", () => {
+  expect(countChar(null, "a")).toEqual("Error: The input string cannot be null or undefined.");
+  expect(countChar(undefined, "a")).toEqual("Error: The input string cannot be null or undefined.");
 });
 
-// Scenario: Empty String
-// Given an empty input string str,
-// And any character char,
-// When the function is called with these inputs,
-// Then it should return 0, as there are no characters to count.
-test("should return error if the string is empty", () => {
-  expect(countChar("", "a")).toEqual("Error: The string cannot be empty.");
+// Edge case: invalid character input
+test("should return error if the character to count is not a single character", () => {
+  expect(countChar("hello", "")).toEqual("Error: The character to count must be a single character.");
+  expect(countChar("hello", "ll")).toEqual("Error: The character to count must be a single character.");
+  expect(countChar("hello", null)).toEqual("Error: The character to count must be a single character.");
+  expect(countChar("hello", undefined)).toEqual("Error: The character to count must be a single character.");
 });
 
-// Scenario: Case Sensitivity
-// Given the input string str containing both uppercase and lowercase versions of a letter,
-// And a character char that matches only one case (either uppercase or lowercase),
-// When the function is called with these inputs,
-// Then it should count only the occurrences matching the exact case of char.
+// Case sensitivity
 test("should count only characters that match the exact case", () => {
   const str = "AaAaA";
-  const lowercaseResult = countChar(str, "a"); // lowercase only
-  const uppercaseResult = countChar(str, "A"); // uppercase only
-  expect(lowercaseResult).toEqual(2); // Only lowercase 'a's
-  expect(uppercaseResult).toEqual(3); // Only uppercase 'A's
+  expect(countChar(str, "a")).toEqual(2); // lowercase only
+  expect(countChar(str, "A")).toEqual(3); // uppercase only
 });
 
-// Scenario: Special Characters
-// Given the input string str containing special or non-alphabetic characters,
-// And a character char that matches one of those special characters,
-// When the function is called with these inputs,
-// Then it should return the number of times that special character occurs in str.
+// Special characters
 test("should count special characters", () => {
   expect(countChar("!?!?", "?")).toEqual(2);
 });
 
-// Scenario: Spaces
-// Given the input string str that contains space characters,
-// And a character char that is a space,
-// When the function is called with these inputs,
-// Then it should return the number of space characters in str.
+// Spaces
 test("should count spaces correctly", () => {
   expect(countChar("a b c", " ")).toEqual(2);
 });
 
-// Scenario: Null or Undefined Input (Optional Defensive Case)
-// Given a null or undefined input string str,
-// And a character char,
-// When the function is called with these inputs,
-// Then it should safely return 0 instead of throwing an error.
-test("should return error if the string is null or undefined", () => {
-  expect(countChar(null, "a")).toEqual(
-    "Error: The input string cannot be null or undefined."
-  );
-  expect(countChar(undefined, "a")).toEqual(
-    "Error: The input string cannot be null or undefined."
-  );
-});
-
-// Scenario: Character Not a Single Character (Optional Defensive Case)
-// Given the input string str,
-// And a character char that is either an empty string or has more than one character,
-// When the function is called with these inputs,
-// Then it should return an error indicating that char must be a single character.
-test("should return error if the character to count is not a single character", () => {
-  expect(countChar("hello", "")).toEqual(
-    "Error: The character to count must be a single character."
-  );
-  expect(countChar("hello", "ll")).toEqual(
-    "Error: The character to count must be a single character."
-  );
-});
-
-// Scenario: Unicode Characters
-// Given the input string str containing Unicode characters (e.g., emojis),
-// And a character char that is a Unicode character,
-// When the function is called with these inputs,
-// Then it should return the number of times that Unicode character occurs in str.
+// Unicode characters
 test("should count unicode characters correctly", () => {
   expect(countChar("😀😃😀😄", "😀")).toEqual(2);
 });
-// Scenario: Long Strings
-// Given a very long input string str,
-// And a character char that occurs multiple times in str,
-// When the function is called with these inputs,
-// Then it should efficiently return the correct count of char in str.
+
+// Long strings
 test("should handle long strings efficiently", () => {
   const longString = "a".repeat(10000) + "b".repeat(5000) + "a".repeat(3000);
   expect(countChar(longString, "a")).toEqual(13000);