London | 26-ITP-May | Jorvan White | Sprint 3 | Practice TDD

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

@@ -1,5 +1,11 @@
 function countChar(stringOfCharacters, findCharacter) {
- return 5
+ let count = 0;
+ for (const char of stringOfCharacters) {
+ if (char === findCharacter) {
+ count++;
+ }
+ }
+ return count;
 }
 
 module.exports = countChar;

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

@@ -22,3 +22,47 @@ 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 character is not found", () => {
+ const str = "hello";
+ const char = "z";
+ const count = countChar(str, char);
+ expect(count).toEqual(0);
+});
+
+test("should return the number of occurrences of a character in a string with different characters", () => {
+ const str = "london";
+ const char = "o";
+ const count = countChar(str, char);
+ expect(count).toEqual(2);
+});
+
+test("should count spaces", () => {
+ const str = "hello world";
+ const char = " ";
+
+ expect(countChar(str, char)).toEqual(1);
+});
+
+test("should only count capitalised characters and when string contains common characters", () => {
+ const str = "Tortilla";
+ const char = "T";
+ const count = countChar(str, char);
+
+ expect(countChar(str, char)).toEqual(1);
+});
+
+test("should return 0 if characters in a string are not capitalised ", () => {
+ const str = "Hello";
+ const char = "L";
+ const count = countChar(str, char);
+
+ expect(countChar(str, char)).toEqual(0);
+});
+
+test("should return 0 if the string doesn't contain any characters", () => {
+ const str = " ";
+ const char = "a";
+
+ expect(countChar(str, char)).toEqual(0);
+});

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

@@ -1,5 +1,19 @@
 function getOrdinalNumber(num) {
- return "1st";
+ if (num % 100 === 11) {
+ return num + "th";
+ } else if (num % 100 === 12) {
+ return num + "th";
+ } else if (num % 100 === 13) {
+ return num + "th";
+ } else if (num % 10 === 1) {
+ return num + "st";
+ } else if (num % 10 === 2) {
+ return num + "nd";
+ } else if (num % 10 === 3) {
+ return num + "rd";
+ } else {
+ return num + "th";
+ }
 }
 
 module.exports = getOrdinalNumber;

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

@@ -18,3 +18,42 @@ test("should append 'st' for numbers ending with 1, except those ending with 11"
  expect(getOrdinalNumber(21)).toEqual("21st");
  expect(getOrdinalNumber(131)).toEqual("131st");
 });
+
+// Case 2: Numbers ending with 11
+test("should append 'th' for numbers ending with 11", () => {
+ expect(getOrdinalNumber(11)).toEqual("11th");
+ expect(getOrdinalNumber(111)).toEqual("111th");
+ expect(getOrdinalNumber(211)).toEqual("211th");
+});
+
+// Case 3: Numbers ending with 3
+test("should append 'rd' for numbers ending with 3 excluding 13", () => {
+ expect(getOrdinalNumber(3)).toEqual("3rd");
+ expect(getOrdinalNumber(23)).toEqual("23rd");
+ expect(getOrdinalNumber(103)).toEqual("103rd");
+});
+
+// Case 4: Numbers ending with 2
+test("should append 'nd' for numbers ending with 2 excluding 12", () => {
+ expect(getOrdinalNumber(2)).toEqual("2nd");
+ expect(getOrdinalNumber(42)).toEqual("42nd");
+ expect(getOrdinalNumber(422)).toEqual("422nd");
+});
+
+// Case 5: Large numbers
+test("should work with larger numbers", () => {
+ expect(getOrdinalNumber(1001)).toEqual("1001st");
+ expect(getOrdinalNumber(1002)).toEqual("1002nd");
+ expect(getOrdinalNumber(1003)).toEqual("1003rd");
+ expect(getOrdinalNumber(1004)).toEqual("1004th");
+});
+
+// Case 6: Numbers ending with 11 and above
+test("should append 'th' for multiple digit numbers where the second to last digit is 1,", () => {
+ expect(getOrdinalNumber(11)).toEqual("11th");
+ expect(getOrdinalNumber(111)).toEqual("111th");
+ expect(getOrdinalNumber(1111)).toEqual("1111th");
+ expect(getOrdinalNumber(3213)).toEqual("3213th");
+ expect(getOrdinalNumber(14)).toEqual("14th");
+ expect(getOrdinalNumber(514)).toEqual("514th");
+});

Sprint-3/2-practice-tdd/repeat-str.js

@@ -1,7 +1,18 @@
-function repeatStr() {
- // Your implementation of this function must *not* call String.prototype.repeat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat).
- // The goal is to re-implement that function, not to use it.
- return "hellohellohello";
+function repeatStr(str, times) {
+ if (typeof times !== "number" || !Number.isInteger(times)) {
+ throw new Error("count must be a whole number");
+ }
+ if (times < 0) {
+ throw new Error("count cannot be negative");
+ }
+
+ let repeatedString = "";
+
+ for (let i = 0; i < times; i++) {
+ repeatedString += str;
+ }
+
+ return repeatedString;
 }
 
 module.exports = repeatStr;

Sprint-3/2-practice-tdd/repeat-str.test.js

@@ -21,12 +21,80 @@ test("should repeat the string count times", () => {
 // When the repeatStr function is called with these inputs,
 // Then it should return the original `str` without repetition.
 
+test("should return the original string when count is 1", () => {
+ const str = "world";
+ const count = 1;
+ const repeatedStr = repeatStr(str, count);
+ expect(repeatedStr).toEqual("world");
+});
+
 // Case: Handle count of 0:
 // Given a target string `str` and a `count` equal to 0,
 // When the repeatStr function is called with these inputs,
 // Then it should return an empty string.
 
+test("should return an empty string when count is 0", () => {
+ const str = "world";
+ const count = 0;
+ const repeatedStr = repeatStr(str, count);
+ expect(repeatedStr).toEqual("");
+});
+
 // Case: Handle negative count:
 // Given a target string `str` and a negative integer `count`,
 // When the repeatStr function is called with these inputs,
 // Then it should throw an error, as negative counts are not valid.
+
+test("should throw an error when count is negative", () => {
+ const str = "world";
+ const count = -1;
+
+ expect(() => {
+ repeatStr(str, count);
+ }).toThrow("count cannot be negative");
+});
+
+// Case: Handle empty string:
+// Given a target string empty `str`,
+// When the repeatStr function is called with any positive amount,
+// Then it should return an empty string.
+
+test("should return an empty string when str is empty", () => {
+ const str = "";
+ const count = 2;
+ const repeatedStr = repeatStr(str, count);
+ expect(repeatedStr).toEqual("");
+});
+
+// Case: Handle non numeric count
+// given a count of a anything not a number
+// Should throw error
+test("should throw an error when count is not a number", () => {
+ const str = "world";
+ const count = "a";
+
+ expect(() => {
+ repeatStr(str, count);
+ }).toThrow("count must be a whole number");
+});
+
+test("should throw an error when str is empty and count is negative", () => {
+ const str = "";
+ const count = -2;
+
+ expect(() => {
+ repeatStr(str, count);
+ }).toThrow("count cannot be negative");
+});
+
+//Case: Handle decimal numbers
+//given a count with a decimal
+//should error
+test("should throw an error when count has a decimal", () => {
+ const str = "world";
+ const count = 3.4;
+
+ expect(() => {
+ repeatStr(str, count);
+ }).toThrow("count must be a whole number");
+});