the implement part is done

Author: HadiVahidi20

Sprint-2/implement/contains.js

@@ -1,3 +1,14 @@
-function contains() {}
+function contains() {function contains(obj, key) {
+  // First, check if obj is a real object
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return false;
+  }
+
+  // Use hasOwnProperty to check if the key exists
+  return obj.hasOwnProperty(key);
+}
+
+module.exports = contains;
+}
 
 module.exports = contains;

Sprint-2/implement/contains.test.js

@@ -20,16 +20,33 @@ as the object doesn't contains a key of 'c'
 // Given an empty object
 // When passed to contains
 // Then it should return false
-test.todo("contains on empty object returns false");
 
+test("contains on empty object returns false", () => {
+  expect(contains({}, "a")).toBe(false);
+});
 // Given an object with properties
 // When passed to contains with an existing property name
 // Then it should return true
+test("contains returns true for existing property", () => {
+  const obj = { a: 1, b: 2 };
+  expect(contains(obj, "a")).toBe(true);
+});
+
 
 // Given an object with properties
 // When passed to contains with a non-existent property name
 // Then it should return false
+test("contains returns false for non-existent property", () => {
+  const obj = { a: 1, b: 2 };
+  expect(contains(obj, "c")).toBe(false);
+});
+
 
 // Given invalid parameters like an array
 // When passed to contains
 // Then it should return false or throw an error
+test("contains returns false for invalid input", () => {
+  expect(contains([], "a")).toBe(false);
+  expect(contains(null, "a")).toBe(false);
+  expect(contains("string", "a")).toBe(false);
+});

Sprint-2/implement/lookup.js

@@ -1,5 +1,20 @@
 function createLookup() {
   // implementation here
+  function createLookup(pairs) {
+  const lookup = {}; 
+
+  for (let i = 0; i < pairs.length; i++) {
+    const pair = pairs[i];          
+    const country = pair[0];        
+    const currency = pair[1];       
+    lookup[country] = currency;     
+  }
+
+  return lookup; 
+}
+
+module.exports = createLookup;
+
 }
 
 module.exports = createLookup;

Sprint-2/implement/lookup.test.js

@@ -33,3 +33,16 @@ It should return:
    'CA': 'CAD'
  }
 */
+
+const createLookup = require("./lookup.js");
+
+test("creates a country currency code lookup for multiple codes", () => {
+  const countryCurrencyPairs = [['US', 'USD'], ['CA', 'CAD'], ['GB', 'GBP']];
+  const result = createLookup(countryCurrencyPairs);
+
+  expect(result).toEqual({
+    'US': 'USD',
+    'CA': 'CAD',
+    'GB': 'GBP'
+  });
+});

Sprint-2/implement/querystring.js

@@ -1,12 +1,17 @@
 function parseQueryString(queryString) {
   const queryParams = {};
-  if (queryString.length === 0) {
+  if (!queryString) {
     return queryParams;
   }
+
   const keyValuePairs = queryString.split("&");
 
   for (const pair of keyValuePairs) {
-    const [key, value] = pair.split("=");
+    const index = pair.indexOf("="); // find the first =
+    if (index === -1) continue;      // skip if no =
+    
+    const key = pair.substring(0, index);       // before the =
+    const value = pair.substring(index + 1);    // after the =
     queryParams[key] = value;
   }
 

Sprint-2/implement/querystring.test.js

@@ -10,3 +10,24 @@ test("parses querystring values containing =", () => {
     "equation": "x=y+1",
   });
 });
+test("parses querystring values containing =", () => {
+  expect(parseQueryString("equation=x=y+1")).toEqual({
+    "equation": "x=y+1",
+  });
+});
+
+test("parses empty query string", () => {
+  expect(parseQueryString("")).toEqual({});
+});
+
+test("parses multiple key-value pairs", () => {
+  expect(parseQueryString("a=1&b=2")).toEqual({ a: "1", b: "2" });
+});
+
+test("parses key with empty value", () => {
+  expect(parseQueryString("foo=")).toEqual({ foo: "" });
+});
+
+test("parses empty key with value", () => {
+  expect(parseQueryString("=bar")).toEqual({ "": "bar" });
+});

Sprint-2/implement/tally.js

@@ -1,3 +1,22 @@
-function tally() {}
+function tally(arr) {
+  if (!Array.isArray(arr)) {
+    throw new Error("Input must be an array");
+  }
+
+  const counts = {}; 
+
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+
+    
+    if (counts[item]) {
+      counts[item] += 1;
+    } else {
+      counts[item] = 1;
+    }
+  }
+
+  return counts; 
+}
 
 module.exports = tally;

Sprint-2/implement/tally.test.js

@@ -23,12 +23,21 @@ const tally = require("./tally.js");
 // Given an empty array
 // When passed to tally
 // Then it should return an empty object
-test.todo("tally on an empty array returns an empty object");
+test("tally on an empty array returns an empty object", () => {
+  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 empty array returns an empty object", () => {
+  expect(tally([])).toEqual({});
+});
+
 
 // Given an invalid input like a string
 // When passed to tally
 // Then it should throw an error
+test("tally throws error for invalid input", () => {
+  expect(() => tally("not an array")).toThrow("Input must be an array");
+});