Testing: ordinal numbers

Author: bytesandroses

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

@@ -1,28 +1,123 @@
 const getOrdinalNumber = require("./get-ordinal-number");
-// In this week's prep, we started implementing getOrdinalNumber.
 
-// Continue testing and implementing getOrdinalNumber for additional cases.
-// Write your tests using Jest — remember to run your tests often for continual feedback.
-
-// To ensure thorough testing, we need broad scenarios that cover all possible cases.
-// Listing individual values, however, can quickly lead to an unmanageable number of test cases.
-// Instead of writing tests for individual numbers, consider grouping all possible input values
-// into meaningful categories. Then, select representative samples from each category to test.
-// This approach improves coverage and makes our tests easier to maintain.
-
-// Case 1: Numbers ending with 1 (but not 11)
-// When the number ends with 1, except those ending with 11,
-// Then the function should return a string by appending "st" to the number.
+// Case 1: Numbers ending with 1 (but not in 11)
 test("should append 'st' for numbers ending with 1, except those ending with 11", () => {
-  expect(getOrdinalNumber(1)).toEqual("1st");
-  expect(getOrdinalNumber(21)).toEqual("21st");
-  expect(getOrdinalNumber(131)).toEqual("131st");
+  const numbers = [1, 21, 131];
+
+  for (const number of numbers) {
+    expect(getOrdinalNumber(number)).toEqual(`${number}st`);
+  }
 });
 
+// Case 2: Numbers ending with 11
 test("should append 'th' for numbers ending with 11", () => {
-  expect(getOrdinalNumber(11)).toEqual("11th");
-  expect(getOrdinalNumber(11)).toEqual("11th");
-  expect(getOrdinalNumber(700011)).toEqual("700011th");
+  const numbers = [11, 111, 700011];
+
+  for (const number of numbers) {
+    expect(getOrdinalNumber(number)).toEqual(`${number}th`);
+  }
+});
+
+// Case 3: Numbers ending with 2 (but not in 12)
+test("should append 'nd' for numbers ending in 2", () => {
+  const numbers = [2, 22, 32, 502];
+
+  for (const number of numbers) {
+    expect(getOrdinalNumber(number)).toEqual(`${number}nd`);
+  }
 });
 
-test();
+// Case 4: Numbers ending with 12
+test("should append 'th' for numbers ending in 12", () => {
+  const numbers = [12, 212, 312, 5012];
+
+  for (const number of numbers) {
+    expect(getOrdinalNumber(number)).toEqual(`${number}th`);
+  }
+});
+
+// Case 5: Numbers ending in 3 (but not in 13)
+test("should append 'rd' for numbers ending in 3 (but not 13)", () => {
+  const numbers = [3, 23, 33, 1063];
+
+  for (const number of numbers) {
+    expect(getOrdinalNumber(number)).toEqual(`${number}rd`);
+  }
+});
+
+// Case 6: Numbers ending in 13
+test("should append 'th' for numbers ending in 13", () => {
+  const numbers = [13, 113, 613, 713];
+
+  for (const number of numbers) {
+    expect(getOrdinalNumber(number)).toEqual(`${number}th`);
+  }
+});
+
+// Case 7: Numbers ending in 4-10
+test("should append 'th' for numbers ending in 4-10", () => {
+  const lastDigits = [4, 5, 6, 7, 8, 9, 10];
+  const bases = [0, 10, 50, 90, 100];
+
+  for (const lastDigit of lastDigits) {
+    for (const base of bases) {
+      const finalNumber = base + lastDigit;
+      expect(getOrdinalNumber(finalNumber)).toEqual(`${finalNumber}th`);
+    }
+  }
+});
+
+// Case 8: Negative numbers
+test("should return ordinal number for negative integer input", () => {
+  const ordinals = [
+    { a: -2, b: "-2nd" },
+    { a: -1, b: "-1st" },
+    { a: -3, b: "-3rd" },
+    { a: -4, b: "-4th" },
+    { a: -11, b: "-11th" },
+    { a: -12, b: "-12th" },
+    { a: -13, b: "-13th" },
+  ];
+
+  for (const { a, b } of ordinals) {
+    expect(getOrdinalNumber(a)).toEqual(b);
+  }
+});
+
+// Case 9: Decimal representations of integers
+test("should return ordinal number for integer in decimal form", () => {
+  const ordinals = [
+    { a: 1.0, b: "1st" },
+    { a: 2.0, b: "2nd" },
+    { a: 3.0, b: "3rd" },
+    { a: 4.0, b: "4th" },
+    { a: -11.0, b: "-11th" },
+    { a: -12.0, b: "-12th" },
+    { a: -13.0, b: "-13th" },
+  ];
+
+  for (const { a, b } of ordinals) {
+    expect(getOrdinalNumber(a)).toEqual(b);
+  }
+});
+
+// Case 10: Invalid entries
+test("should throw error for invalid inputs", () => {
+  const invalidEntries = [
+    "one",
+    "",
+    [1],
+    null,
+    undefined,
+    9.5,
+    8.00001,
+    {},
+    true,
+  ];
+
+  for (const entry of invalidEntries) {
+    expect(() => {
+      getOrdinalNumber(entry);
+    }).toThrow();
+  }
+});