Glasgow | 26-ITP-Jan| Martin McLean |Sprint 3| practice TDD coursework

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

@@ -1,5 +1,14 @@
 function countChar(stringOfCharacters, findCharacter) {
-  return 5
+const totalCount=stringOfCharacters.split("");
+let count=0
+for(let i=0; i<totalCount.length; i++){
+    if(totalCount[i]===findCharacter){
+        count++
+    }
 }
-
+return count
+}
+console.log(countChar("aaaa","a"))
 module.exports = countChar;
+
+

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

@@ -11,14 +11,19 @@ const countChar = require("./count");
 // Then it should correctly count occurrences of `char`.
 
 test("should count multiple occurrences of a character", () => {
-  const str = "aaaaa";
-  const char = "a";
-  const count = countChar(str, char);
-  expect(count).toEqual(5);
+  expect(countChar("aaaaa","a")).toEqual(5);
 });
 
 // Scenario: No Occurrences
+test(`should return 0 in the instance of no char counted`,() =>{
+  expect(countChar("","a")).toEqual(0);
+});
+
+//});
 // Given the input string `str`,
-// And a character `char` that does not exist within `str`.
+test(` character char that does not exist within str`,()=>{
+  expect(countChar("aaaaa","b")).toEqual(0);
+});
+
 // When the function is called with these inputs,
 // Then it should return 0, indicating that no occurrences of `char` were found.

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

@@ -1,5 +1,21 @@
 function getOrdinalNumber(num) {
-  return "1st";
+
+  if (num >=11 &&  num <= 19){
+    return `${num}th`
+  };
+
+
+  const lastDigit = num % 10
+  switch (lastDigit) {
+    case 1:
+      return `${num}st`;
+    case 2:
+      return `${num}nd`;
+    case 3:
+      return `${num}rd`;
+    default:
+      return `${num}th`;
+  }
 }
 
 module.exports = getOrdinalNumber;

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

@@ -18,3 +18,23 @@ test("should append 'st' for numbers ending with 1, except those ending with 11"
   expect(getOrdinalNumber(21)).toEqual("21st");
   expect(getOrdinalNumber(131)).toEqual("131st");
 });
+test("should append 'st' for numbers ending with 1, except those ending with 11", () => {
+  expect(getOrdinalNumber(2)).toEqual("2nd");
+  expect(getOrdinalNumber(22)).toEqual("22nd");
+  expect(getOrdinalNumber(132)).toEqual("132nd");
+  });
+  test("should append 'st' for numbers ending with 1, except those ending with 11", () => {
+  expect(getOrdinalNumber(3)).toEqual("3rd");
+  expect(getOrdinalNumber(23)).toEqual("23rd");
+  expect(getOrdinalNumber(133)).toEqual("133rd");
+  });
+  test("should append 'st' for numbers ending with 1, except those ending with 11", () => {
+  expect(getOrdinalNumber(4)).toEqual("4th");
+  expect(getOrdinalNumber(25)).toEqual("25th");
+  expect(getOrdinalNumber(134)).toEqual("134th");
+  });
+  test("should append 'st' for numbers ending with 1, except those ending with 11", () => {
+  expect(getOrdinalNumber(11)).toEqual("11th");
+  expect(getOrdinalNumber(14)).toEqual("14th");
+  expect(getOrdinalNumber(18)).toEqual("18th");
+  });

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

@@ -1,5 +1,8 @@
-function repeatStr() {
-  return "hellohellohello";
-}
+function repeatStr(times, str) {
+  if (times < 0){ throw ("error input required to repeat")}
+  return str.repeat(times);
+
+} 
+
 
 module.exports = repeatStr;

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

@@ -10,23 +10,28 @@ const repeatStr = require("./repeat-str");
 // Then it should return a string that contains the original `str` repeated `count` times.
 
 test("should repeat the string count times", () => {
-  const str = "hello";
-  const count = 3;
-  const repeatedStr = repeatStr(str, count);
-  expect(repeatedStr).toEqual("hellohellohello");
+  expect (repeatStr(3 ,"hi")).toEqual("hihihi");
 });
 
 // Case: handle count of 1:
 // Given a target string `str` and a `count` equal to 1,
 // When the repeatStr function is called with these inputs,
 // Then it should return the original `str` without repetition.
+test("should when Given a target string `str` and a `count` equal to 1", () => {
+  expect (repeatStr(1 ,"hi")).toEqual("hi");
+});
 
 // 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 when Given a target string `str` and a `count` equal to 0", () => {
+  expect (repeatStr(0 ,"hi")).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.
+