updated function implementations.

Author: Bluejay600

Sprint-2/implement/querystring.test.js

@@ -7,46 +7,26 @@
 
 const parseQueryString = require("./querystring.js")
 
-test("parses querystring with single value", () => {
-  expect(parseQueryString("a=1")).toEqual({"a": "1",
+test("parses querystring values containing =", () => {
+  expect(parseQueryString("equation=x=y+1")).toEqual({
+    "equation": "x=y+1",
   });
 });
-test("parses querystring with multiple values", () => {
-  expect(parseQueryString("a=1&b=2")).toEqual({
-    "a": "1",
-    "b": "2",
-  });
+test("parses multiple key-value pairs", () => {
+  expect(parseQueryString("a=1&b=2")).toEqual({ a: "1", b: "2" });
 });
-
-//other edge cases
-test("handles empty query string", () => {
+test("parses empty string as empty object", () => {
   expect(parseQueryString("")).toEqual({});
 });
-test("handles query string with no key-value pairs", () => {
-  expect(parseQueryString("&&")).toEqual({});
-});
-test("handles query string with only keys", () => {
-  expect(parseQueryString("key1&key2")).toEqual({
-    key1: undefined,
-    key2: undefined
-  });
+test("parses values with spaces encoded as +", () => {
+  expect(parseQueryString("name=John+Doe")).toEqual({ name: "John Doe" });
 });
 
-test("handles missing value", () => {
-  expect(parseQueryString("foo=")).toEqual({ foo: "" });
+test("parses URL encoded special characters", () => {
+  expect(parseQueryString("text=Hello%2C%20World%21")).toEqual({ text: "Hello, World!" });
 });
 
-test("handles missing key", () => {
-  expect(parseQueryString("=bar")).toEqual({ "": "bar" });
-});
-test("handles multiple key-value pairs", () => {
-  expect(parseQueryString("key1=value1&key2=value2")).toEqual({
-    key1: "value1",
-    key2: "value2"
-  });
-});
-test("handles multiple key-value pairs with same key", () => {
-  expect(parseQueryString("key=value1&key=value2")).toEqual({
-    key: "value2" // last value should overwrite previous
-  });
-});
+test("parses values containing equals sign for any key", () => {
+  expect(parseQueryString("formula=a=b+c")).toEqual({ formula: "a=b+c" });
+  expect(parseQueryString("expression=x=5&result=y=10")).toEqual({ expression: "x=5", result: "y=10" });
+});

Sprint-2/implement/tally.js

@@ -1,12 +1,22 @@
-function tally(arr) {
-  if (!Array.isArray(arr)) {
+function tally(countFrequency) {
+  if (!Array.isArray(countFrequency)) {
     throw new Error("Input must be an array");
   }
- return arr.reduce((acc, item) => {
-  acc[item] = (acc[item] || 0) + 1;
-  return acc;
-}, Object.create(null));
 
+  if (countFrequency.length === 0) {
+    return {};
+  }
+
+  const result = {};
+  for (item of countFrequency) {
+    if (result[item]) {
+      result[item]++;
+    } else {
+      result[item] = 1;
+    }
+  }
+  return result;
 }
+console.log(tally(["a", "a", "a"]));
 
-module.exports = tally;
+module.exports = tally;

Sprint-2/implement/tally.test.js

@@ -19,36 +19,32 @@ const tally = require("./tally.js");
 // Given a function called tally
 // When passed an array of items
 // Then it should return an object containing the count for each unique item
-test("tally on an array of items returns an object with counts", () => {
-  const input = ['a', 'a', 'b', 'c'];
-  const expectedOutput = { a: 2, b: 1, c: 1 };
-  
-  expect(tally(input)).toEqual(expectedOutput);
+test("counts item correctly", () => {
+  const input = ["a", "b", "c"];
+  const output = { a: 1, b: 1, c: 1 };
+  expect(tally(input)).toEqual(output);
 });
-
 // Given an empty array
 // When passed to tally
 // Then it should return an empty object
 test("tally on an empty array returns an empty object", () => {
-  const input = [];
-  const expectedOutput = {};
-  
-  expect(tally(input)).toEqual(expectedOutput);
+  expect(tally([])).toEqual({});
 });
 
 // Given an array with duplicate items
 // When passed to tally
 // Then it should return counts for each unique item
-test("tally on an array with duplicates returns correct counts", () => {
-  const input = ['a', 'b', 'a', 'c', 'b', 'b'];
-  const expectedOutput = { a: 2, b: 3, c: 1 };
-  
-  expect(tally(input)).toEqual(expectedOutput);
+test("Given an array with duplicate items", () => {
+  const input = ["a", "a", "b", "c"];
+  const output = { a: 2, b: 1, c: 1 };
+  expect(tally(input)).toEqual(output);
 });
 
 // Given an invalid input like a string
 // When passed to tally
 // Then it should throw an error
-test("tally throws an error for non-array input", () => {
-  expect(() => tally("not an array")).toThrow("Input must be an array");
-});
+test("Given an invalid input like a string, when passed to tally, then it should throw an error", () => {
+  expect(() => {
+    tally("invalid string input");
+  }).toThrow("Input must be an array");
+});