From 2b5f14cf6979706d394a7699aa00f2b5e9d02bbb Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Mon, 31 Jan 2022 16:37:54 -0500
Subject: [PATCH 01/46] Require Hello World in the document

---
 src/text.Test.tsx | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 src/text.Test.tsx

diff --git a/src/text.Test.tsx b/src/text.Test.tsx
new file mode 100644
index 0000000000..b32c330d3f
--- /dev/null
+++ b/src/text.Test.tsx
@@ -0,0 +1,9 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import App from "./App";
+
+test("renders the text 'Hello World' somewhere", () => {
+    render(<App />);
+    const text = screen.getByText(/Hello World/);
+    expect(text).toBeInTheDocument();
+});

From a7dee05e0bee0379110c6189433d12482280146a Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Mon, 31 Jan 2022 16:41:17 -0500
Subject: [PATCH 02/46] Rename text.Test.tsx to text.test.tsx

---
 src/{text.Test.tsx => text.test.tsx} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/{text.Test.tsx => text.test.tsx} (100%)

diff --git a/src/text.Test.tsx b/src/text.test.tsx
similarity index 100%
rename from src/text.Test.tsx
rename to src/text.test.tsx

From 3e381f38b1d44afd102eb053a8ba9a48a069434e Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Mon, 31 Jan 2022 16:56:42 -0500
Subject: [PATCH 03/46] Include the task info

---
 public/tasks/task-first-branch.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 public/tasks/task-first-branch.md

diff --git a/public/tasks/task-first-branch.md b/public/tasks/task-first-branch.md
new file mode 100644
index 0000000000..94333338a0
--- /dev/null
+++ b/public/tasks/task-first-branch.md
@@ -0,0 +1,5 @@
+# Task - First Branch
+
+Version: 0.0.1
+
+Pass a short test to have certain text on the page.

From e6b1dab1961daf6f03459789cef974bf043501f2 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Thu, 3 Feb 2022 14:10:55 -0500
Subject: [PATCH 04/46] Allow one or more instances of the Hello World text

---
 src/text.test.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/text.test.tsx b/src/text.test.tsx
index b32c330d3f..f99a063e76 100644
--- a/src/text.test.tsx
+++ b/src/text.test.tsx
@@ -4,6 +4,6 @@ import App from "./App";
 
 test("renders the text 'Hello World' somewhere", () => {
     render(<App />);
-    const text = screen.getByText(/Hello World/);
-    expect(text).toBeInTheDocument();
+    const texts = screen.getAllByText(/Hello World/);
+    expect(texts.length).toBeGreaterThanOrEqual(1);
 });

From 7a207345d9e404afd04607811b89bb758de02905 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sat, 24 Aug 2024 12:52:12 -0400
Subject: [PATCH 05/46] Include json test command here

---
 package.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/package.json b/package.json
index cf6e1bc772..fc2b66a549 100644
--- a/package.json
+++ b/package.json
@@ -20,6 +20,7 @@
         "build": "react-scripts build",
         "test": "react-scripts test",
         "test:cov": "react-scripts test --coverage --watchAll",
+        "test:json": "react-scripts test --json --watchAll=false --outputFile jest-output.json --coverage",
         "eject": "react-scripts eject",
         "lint": "eslint ./src --ext .tsx --ext .ts --max-warnings 0",
         "eslint-output": "eslint-output ./src --ext .tsx --ext .ts --max-warnings 0",

From 7fe9ca316fad2e694586e037fe601b85a2584c56 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Mon, 31 Jan 2022 16:37:54 -0500
Subject: [PATCH 06/46] Require Hello World in the document

---
 src/text.Test.tsx | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 src/text.Test.tsx

diff --git a/src/text.Test.tsx b/src/text.Test.tsx
new file mode 100644
index 0000000000..b32c330d3f
--- /dev/null
+++ b/src/text.Test.tsx
@@ -0,0 +1,9 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import App from "./App";
+
+test("renders the text 'Hello World' somewhere", () => {
+    render(<App />);
+    const text = screen.getByText(/Hello World/);
+    expect(text).toBeInTheDocument();
+});

From b8b8878c873d4faa2fd5f04d656e23d66c7d6cef Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Mon, 31 Jan 2022 16:56:42 -0500
Subject: [PATCH 07/46] Include the task info

---
 public/tasks/task-first-branch.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 public/tasks/task-first-branch.md

diff --git a/public/tasks/task-first-branch.md b/public/tasks/task-first-branch.md
new file mode 100644
index 0000000000..94333338a0
--- /dev/null
+++ b/public/tasks/task-first-branch.md
@@ -0,0 +1,5 @@
+# Task - First Branch
+
+Version: 0.0.1
+
+Pass a short test to have certain text on the page.

From fbdebdec2006b01d3976bd9408037baf82eb5e56 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Mon, 31 Jan 2022 16:41:17 -0500
Subject: [PATCH 08/46] Rename text.Test.tsx to text.test.tsx

---
 src/{text.Test.tsx => text.test.tsx} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/{text.Test.tsx => text.test.tsx} (100%)

diff --git a/src/text.Test.tsx b/src/text.test.tsx
similarity index 100%
rename from src/text.Test.tsx
rename to src/text.test.tsx

From 2f0146c22beca5c5ac48603876f0fa8ea2e2e905 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Thu, 3 Feb 2022 14:10:55 -0500
Subject: [PATCH 09/46] Allow one or more instances of the Hello World text

---
 src/text.test.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/text.test.tsx b/src/text.test.tsx
index b32c330d3f..f99a063e76 100644
--- a/src/text.test.tsx
+++ b/src/text.test.tsx
@@ -4,6 +4,6 @@ import App from "./App";
 
 test("renders the text 'Hello World' somewhere", () => {
     render(<App />);
-    const text = screen.getByText(/Hello World/);
-    expect(text).toBeInTheDocument();
+    const texts = screen.getAllByText(/Hello World/);
+    expect(texts.length).toBeGreaterThanOrEqual(1);
 });

From ac36b32302a8ea2e66b4b954626c8e396e172075 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sat, 29 Jan 2022 23:59:24 -0500
Subject: [PATCH 10/46] First set of tests

---
 public/tasks/task-html-css.md |  5 +++++
 src/HtmlCss.test.tsx          | 28 ++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+)
 create mode 100644 public/tasks/task-html-css.md
 create mode 100644 src/HtmlCss.test.tsx

diff --git a/public/tasks/task-html-css.md b/public/tasks/task-html-css.md
new file mode 100644
index 0000000000..ebc0efcba5
--- /dev/null
+++ b/public/tasks/task-html-css.md
@@ -0,0 +1,5 @@
+# Task - HTML/CSS
+
+Version: 0.0.1
+
+Add in some HTML and CSS, including a fancy looking button.
diff --git a/src/HtmlCss.test.tsx b/src/HtmlCss.test.tsx
new file mode 100644
index 0000000000..168ce37fde
--- /dev/null
+++ b/src/HtmlCss.test.tsx
@@ -0,0 +1,28 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import App from "./App";
+
+describe("Some HTML Elements are added.", () => {
+    test("There is a header", () => {
+        render(<App />);
+        const header = screen.getByRole("heading");
+        expect(header).toBeInTheDocument();
+    });
+});
+
+describe("Some basic CSS is added.", () => {
+    test("There is a floating red box", () => {
+        render(<App />);
+        expect(true);
+    });
+});
+
+describe("Some Bootstrap Elements are added", () => {
+    test("There is a bootstrap button", () => {
+        render(<App />);
+        const button = screen.getByRole("button");
+        expect(button).toBeInTheDocument();
+        expect(button).toHaveClass("btn");
+        expect(button).toHaveClass("btn-primary");
+    });
+});

From d04739d1d2ec0c934c0ecf1dc05ac1289063627d Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sun, 30 Jan 2022 00:24:38 -0500
Subject: [PATCH 11/46] Some logging tests

---
 src/HtmlCss.test.tsx | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/HtmlCss.test.tsx b/src/HtmlCss.test.tsx
index 168ce37fde..bf957616f9 100644
--- a/src/HtmlCss.test.tsx
+++ b/src/HtmlCss.test.tsx
@@ -1,6 +1,7 @@
 import React from "react";
 import { render, screen } from "@testing-library/react";
 import App from "./App";
+import userEvent from "@testing-library/user-event";
 
 describe("Some HTML Elements are added.", () => {
     test("There is a header", () => {
@@ -18,11 +19,25 @@ describe("Some basic CSS is added.", () => {
 });
 
 describe("Some Bootstrap Elements are added", () => {
-    test("There is a bootstrap button", () => {
+    test("There is one bootstrap button with the text 'Log Hello World'", () => {
         render(<App />);
-        const button = screen.getByRole("button");
+        const button = screen.getByRole("button", { name: /Log Hello World/i });
         expect(button).toBeInTheDocument();
         expect(button).toHaveClass("btn");
         expect(button).toHaveClass("btn-primary");
     });
+
+    test("Not clicking the bootstrap button does not logs 'Hello World!'", () => {
+        const consoleSpy = jest.spyOn(console, "log");
+        render(<App />);
+        expect(consoleSpy).not.toHaveBeenCalledWith("Hello World!");
+    });
+
+    test("Clicking the bootstrap button logs 'Hello World!'", () => {
+        const consoleSpy = jest.spyOn(console, "log");
+        render(<App />);
+        const button = screen.getByRole("button", { name: /Log Hello World/i });
+        userEvent.click(button);
+        expect(consoleSpy).toHaveBeenCalledWith("Hello World!");
+    });
 });

From b26100f543943eced73fdff33784861243c65386 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sun, 30 Jan 2022 00:47:43 -0500
Subject: [PATCH 12/46] More html tests

---
 src/HtmlCss.test.tsx | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/HtmlCss.test.tsx b/src/HtmlCss.test.tsx
index bf957616f9..676c37f903 100644
--- a/src/HtmlCss.test.tsx
+++ b/src/HtmlCss.test.tsx
@@ -9,6 +9,20 @@ describe("Some HTML Elements are added.", () => {
         const header = screen.getByRole("heading");
         expect(header).toBeInTheDocument();
     });
+
+    test("There is an image with alt text", () => {
+        render(<App />);
+        const image = screen.getByRole("image");
+        expect(image).toBeInTheDocument();
+        expect(image).toHaveAttribute("alt");
+    });
+
+    test("There is a list with at least three elements", () => {
+        render(<App />);
+        const list = screen.getByRole("list");
+        expect(list).toBeInTheDocument();
+        expect(list.children.length).toBeGreaterThanOrEqual(3);
+    });
 });
 
 describe("Some basic CSS is added.", () => {

From 3bf4550a8f042dee28a57c06abec05dfce779519 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sun, 30 Jan 2022 00:55:24 -0500
Subject: [PATCH 13/46] Fix the image test

---
 src/HtmlCss.test.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/HtmlCss.test.tsx b/src/HtmlCss.test.tsx
index 676c37f903..79b7db2dda 100644
--- a/src/HtmlCss.test.tsx
+++ b/src/HtmlCss.test.tsx
@@ -12,7 +12,7 @@ describe("Some HTML Elements are added.", () => {
 
     test("There is an image with alt text", () => {
         render(<App />);
-        const image = screen.getByRole("image");
+        const image = screen.getByRole("img");
         expect(image).toBeInTheDocument();
         expect(image).toHaveAttribute("alt");
     });

From 8dff2b64a2efc0b1b49703077965fe5e334eab1a Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Mon, 31 Jan 2022 16:31:58 -0500
Subject: [PATCH 14/46] Updated CSS tests, left a note about additional tests

---
 src/HtmlCss.test.tsx | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/HtmlCss.test.tsx b/src/HtmlCss.test.tsx
index 79b7db2dda..379fc8f449 100644
--- a/src/HtmlCss.test.tsx
+++ b/src/HtmlCss.test.tsx
@@ -30,6 +30,14 @@ describe("Some basic CSS is added.", () => {
         render(<App />);
         expect(true);
     });
+
+    test("The background color of the header area is different", () => {
+        render(<App />);
+        const banner = screen.getByRole("banner");
+        expect(banner).not.toHaveStyle({
+            "background-color": "rgb(40, 44, 52)"
+        });
+    });
 });
 
 describe("Some Bootstrap Elements are added", () => {

From b66d4de909f74de4cba160a6fff05b078b9b47cc Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Mon, 31 Jan 2022 16:32:13 -0500
Subject: [PATCH 15/46] See previous commit message

---
 src/HtmlCss.test.tsx | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/HtmlCss.test.tsx b/src/HtmlCss.test.tsx
index 379fc8f449..36767ad350 100644
--- a/src/HtmlCss.test.tsx
+++ b/src/HtmlCss.test.tsx
@@ -26,11 +26,6 @@ describe("Some HTML Elements are added.", () => {
 });
 
 describe("Some basic CSS is added.", () => {
-    test("There is a floating red box", () => {
-        render(<App />);
-        expect(true);
-    });
-
     test("The background color of the header area is different", () => {
         render(<App />);
         const banner = screen.getByRole("banner");
@@ -63,3 +58,7 @@ describe("Some Bootstrap Elements are added", () => {
         expect(consoleSpy).toHaveBeenCalledWith("Hello World!");
     });
 });
+
+/**
+ * Remember, there are additional tasks described on the page!
+ */

From 0a24364f67b1ee221ebe175d6c494d5eca6ad7dc Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sat, 24 Aug 2024 13:10:09 -0400
Subject: [PATCH 16/46] Add in new css test

---
 src/HtmlCss.test.tsx | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/src/HtmlCss.test.tsx b/src/HtmlCss.test.tsx
index 36767ad350..48b0a6df2d 100644
--- a/src/HtmlCss.test.tsx
+++ b/src/HtmlCss.test.tsx
@@ -30,7 +30,7 @@ describe("Some basic CSS is added.", () => {
         render(<App />);
         const banner = screen.getByRole("banner");
         expect(banner).not.toHaveStyle({
-            "background-color": "rgb(40, 44, 52)"
+            "background-color": "rgb(40, 44, 52)",
         });
     });
 });
@@ -59,6 +59,25 @@ describe("Some Bootstrap Elements are added", () => {
     });
 });
 
-/**
- * Remember, there are additional tasks described on the page!
- */
+describe("Some additional CSS was added", () => {
+    test("checks if any element has a background color of red", () => {
+        const { container } = render(<App />);
+        // Get all elements in the rendered container
+        const elements = container.querySelectorAll("*");
+
+        // Check if any element has a background color of red
+        let foundRedBackground = false;
+
+        elements.forEach((element) => {
+            const style = getComputedStyle(element);
+            if (
+                style.backgroundColor === "red" ||
+                style.backgroundColor === "rgb(255, 0, 0)"
+            ) {
+                foundRedBackground = true;
+            }
+        });
+
+        expect(foundRedBackground).toBe(true);
+    });
+});

From 4d43d7a5d133522b0a8d92e1cb3d7e4053a81992 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sat, 24 Aug 2024 13:12:28 -0400
Subject: [PATCH 17/46] Add in points

---
 src/HtmlCss.test.tsx | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/HtmlCss.test.tsx b/src/HtmlCss.test.tsx
index 48b0a6df2d..320cb97524 100644
--- a/src/HtmlCss.test.tsx
+++ b/src/HtmlCss.test.tsx
@@ -4,20 +4,20 @@ import App from "./App";
 import userEvent from "@testing-library/user-event";
 
 describe("Some HTML Elements are added.", () => {
-    test("There is a header", () => {
+    test("(2 pts) There is a header", () => {
         render(<App />);
         const header = screen.getByRole("heading");
         expect(header).toBeInTheDocument();
     });
 
-    test("There is an image with alt text", () => {
+    test("(2 pts) There is an image with alt text", () => {
         render(<App />);
         const image = screen.getByRole("img");
         expect(image).toBeInTheDocument();
         expect(image).toHaveAttribute("alt");
     });
 
-    test("There is a list with at least three elements", () => {
+    test("(2 pts) There is a list with at least three elements", () => {
         render(<App />);
         const list = screen.getByRole("list");
         expect(list).toBeInTheDocument();
@@ -25,7 +25,7 @@ describe("Some HTML Elements are added.", () => {
     });
 });
 
-describe("Some basic CSS is added.", () => {
+describe("(2 pts) Some basic CSS is added.", () => {
     test("The background color of the header area is different", () => {
         render(<App />);
         const banner = screen.getByRole("banner");
@@ -35,7 +35,7 @@ describe("Some basic CSS is added.", () => {
     });
 });
 
-describe("Some Bootstrap Elements are added", () => {
+describe("(2 pts) Some Bootstrap Elements are added", () => {
     test("There is one bootstrap button with the text 'Log Hello World'", () => {
         render(<App />);
         const button = screen.getByRole("button", { name: /Log Hello World/i });
@@ -44,13 +44,13 @@ describe("Some Bootstrap Elements are added", () => {
         expect(button).toHaveClass("btn-primary");
     });
 
-    test("Not clicking the bootstrap button does not logs 'Hello World!'", () => {
+    test("(2 pts) Not clicking the bootstrap button does not logs 'Hello World!'", () => {
         const consoleSpy = jest.spyOn(console, "log");
         render(<App />);
         expect(consoleSpy).not.toHaveBeenCalledWith("Hello World!");
     });
 
-    test("Clicking the bootstrap button logs 'Hello World!'", () => {
+    test("(2 pts) Clicking the bootstrap button logs 'Hello World!'", () => {
         const consoleSpy = jest.spyOn(console, "log");
         render(<App />);
         const button = screen.getByRole("button", { name: /Log Hello World/i });
@@ -60,7 +60,7 @@ describe("Some Bootstrap Elements are added", () => {
 });
 
 describe("Some additional CSS was added", () => {
-    test("checks if any element has a background color of red", () => {
+    test("(2 pts) checks if any element has a background color of red", () => {
         const { container } = render(<App />);
         // Get all elements in the rendered container
         const elements = container.querySelectorAll("*");

From 7cc4e3f20e61307e9f22eb466fe21871b3eefbd3 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Tue, 1 Feb 2022 14:51:32 -0500
Subject: [PATCH 18/46] First stab at array problems

---
 public/tasks/task-arrays.md |  5 +++
 src/arrays.test.ts          | 12 ++++++
 src/arrays.ts               | 84 +++++++++++++++++++++++++++++++++++++
 3 files changed, 101 insertions(+)
 create mode 100644 public/tasks/task-arrays.md
 create mode 100644 src/arrays.test.ts
 create mode 100644 src/arrays.ts

diff --git a/public/tasks/task-arrays.md b/public/tasks/task-arrays.md
new file mode 100644
index 0000000000..c2fbf80f8d
--- /dev/null
+++ b/public/tasks/task-arrays.md
@@ -0,0 +1,5 @@
+# Task - Arrays
+
+Version: 0.0.1
+
+Implement functions that work with arrays immutably.
diff --git a/src/arrays.test.ts b/src/arrays.test.ts
new file mode 100644
index 0000000000..b812349d2f
--- /dev/null
+++ b/src/arrays.test.ts
@@ -0,0 +1,12 @@
+import { bookEndList } from "./arrays";
+
+describe("Testing the array functions", () => {
+    const NUMBERS_1 = [1, 2, 3];
+
+    test("Testing the bookEndList function", () => {
+        // Ensure that the original array was not changed
+        expect(bookEndList(NUMBERS_1)).not.toBe(NUMBERS_1);
+        // And that a correct new array was returned
+        expect(bookEndList(NUMBERS_1)).toEqual([1, 3]);
+    });
+});
diff --git a/src/arrays.ts b/src/arrays.ts
new file mode 100644
index 0000000000..7604b40cdb
--- /dev/null
+++ b/src/arrays.ts
@@ -0,0 +1,84 @@
+/**
+ * Consume an array of numbers, and return a new array containing
+ * JUST the first and last number. If there are no elements, return
+ * an empty array. If there is one element, the resulting list should
+ * the number twice.
+ */
+export function bookEndList(numbers: number[]): number[] {
+    return numbers;
+}
+
+/**
+ * Consume an array of numbers, and return a new array where each
+ * number has been tripled (multiplied by 3).
+ */
+export function tripleNumbers(numbers: number[]): number[] {
+    return numbers;
+}
+
+/**
+ * Consume an array of strings and convert them to integers. If
+ * the number cannot be parsed as an integer, convert it to "?" instead.
+ */
+export function stringsToIntegers(numbers: string[]): number[] {
+    return [];
+}
+
+/**
+ * Consume an array of strings and return them as numbers. Note that
+ * the strings MAY have "$" symbols at the beginning, in which case
+ * those should be removed. If the result cannot be parsed as an integer,
+ * convert it to "?" instead.
+ */
+// Remember, you can write functions as lambdas too! They work exactly the same.
+export const removeDollars = (amounts: string[]): number[] => {
+    return [];
+};
+
+/**
+ * Consume an array of messages and return a new list of the messages. However, any
+ * string that ends in "!" should be made uppercase.
+ */
+export const shoutIfExclaiming = (messages: string[]): string[] => {
+    return [];
+};
+
+/**
+ * Consumes an array of words and returns the number of words that are LESS THAN
+ * 4 letters long.
+ */
+export function countShortWords(words: string[]): number {
+    return 0;
+}
+
+/**
+ * Consumes an array of colors (e.g., 'red', 'purple') and returns true if ALL
+ * the colors are either 'red', 'blue', or 'green'. If an empty list is given,
+ * then return true.
+ */
+export function allRGB(colors: string[]): boolean {
+    return false;
+}
+
+/**
+ * Consumes an array of numbers, and produces a string representation of the
+ * numbers being added together along with their actual sum.
+ *
+ * For instance, the array [1, 2, 3] would become "6=1+2+3".
+ */
+export function makeMath(addends: number[]): string {
+    return "";
+}
+
+/**
+ * Consumes an array of numbers and produces a new array of the same numbers,
+ * with one difference. After the FIRST negative number, insert the sum of all
+ * previous numbers in the list. If there are no negative numbers, then append
+ * 0 to the list.
+ *
+ * For instance, the array [1, 9, -5, 7] would become [1, 9, -5, 10, 7]
+ * And the array [1, 9, 7] would become [1, 9, 0]
+ */
+export function injectPositive(values: number[]): number[] {
+    return [];
+}

From f25333778032fc42866a278af6a3ce871f735150 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Tue, 1 Feb 2022 16:09:10 -0500
Subject: [PATCH 19/46] Add in the rest of the tests

---
 src/arrays.test.ts | 269 ++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 265 insertions(+), 4 deletions(-)

diff --git a/src/arrays.test.ts b/src/arrays.test.ts
index b812349d2f..0881d9fe8a 100644
--- a/src/arrays.test.ts
+++ b/src/arrays.test.ts
@@ -1,12 +1,273 @@
-import { bookEndList } from "./arrays";
+import {
+    allRGB,
+    bookEndList,
+    countShortWords,
+    injectPositive,
+    makeMath,
+    removeDollars,
+    shoutIfExclaiming,
+    stringsToIntegers,
+    tripleNumbers
+} from "./arrays";
 
 describe("Testing the array functions", () => {
+    //////////////////////////////////
+    // bookEndList and tripleNumbers
+
     const NUMBERS_1 = [1, 2, 3];
+    const NUMBERS_2 = [100, 300, 200];
+    const NUMBERS_3 = [5];
+    const NUMBERS_4: number[] = [];
+    const NUMBERS_5 = [100, 199, 1, -5, 7, 3];
+    const NUMBERS_6 = [-100, -200, 100, 200];
+    const NUMBERS_7 = [199, 1, 550, 50, 200];
+
+    // Ensure that none of the arrays were changed mutably
+    // If you fail these, you aren't using map/filter/reduce/etc. properly!
+    afterEach(() => {
+        expect(NUMBERS_1).toEqual([1, 2, 3]);
+        expect(NUMBERS_2).toEqual([100, 300, 200]);
+        expect(NUMBERS_3).toEqual([5]);
+        expect(NUMBERS_4).toEqual([]);
+        expect(NUMBERS_5).toEqual([100, 199, 1, -5, 7, 3]);
+        expect(NUMBERS_6).toEqual([-100, -200, 100, 200]);
+        expect(NUMBERS_7).toEqual([199, 1, 550, 50, 200]);
+    });
 
     test("Testing the bookEndList function", () => {
-        // Ensure that the original array was not changed
-        expect(bookEndList(NUMBERS_1)).not.toBe(NUMBERS_1);
-        // And that a correct new array was returned
         expect(bookEndList(NUMBERS_1)).toEqual([1, 3]);
+        expect(bookEndList(NUMBERS_2)).toEqual([100, 200]);
+        expect(bookEndList(NUMBERS_3)).toEqual([5, 5]);
+        expect(bookEndList(NUMBERS_4)).toEqual([]);
+        expect(bookEndList(NUMBERS_5)).toEqual([100, 3]);
+        expect(bookEndList(NUMBERS_6)).toEqual([-100, 200]);
+    });
+
+    test("Testing the tripleNumbers function", () => {
+        expect(tripleNumbers(NUMBERS_1)).toEqual([3, 6, 9]);
+        expect(tripleNumbers(NUMBERS_2)).toEqual([300, 900, 600]);
+        expect(tripleNumbers(NUMBERS_3)).toEqual([15]);
+        expect(tripleNumbers(NUMBERS_4)).toEqual([]);
+        expect(tripleNumbers(NUMBERS_5)).toEqual([300, 597, 3, -15, 21, 9]);
+        expect(tripleNumbers(NUMBERS_6)).toEqual([-300, -600, 300, 600]);
+    });
+
+    //////////////////////////////////
+    // stringsToIntegers
+
+    const VALUES_1 = ["1", "2", "3"];
+    const VALUES_2 = ["100", "200", "300"];
+    const VALUES_3 = ["5"];
+    const VALUES_4: string[] = [];
+    const VALUES_5 = ["100", "?", "27", "$44"];
+    const VALUES_6 = ["-1", "0", "1", "*1"];
+    const VALUES_7 = ["apple", "banana", "cactus"];
+
+    // Ensure that none of the arrays were changed mutably
+    // If you fail these, you aren't using map/filter/reduce/etc. properly!
+    afterEach(() => {
+        expect(VALUES_1).toEqual(["1", "2", "3"]);
+        expect(VALUES_2).toEqual(["100", "200", "300"]);
+        expect(VALUES_3).toEqual(["5"]);
+        expect(VALUES_4).toEqual([]);
+        expect(VALUES_5).toEqual(["100", "?", "27", "$44"]);
+        expect(VALUES_6).toEqual(["-1", "0", "1", "*1"]);
+        expect(VALUES_7).toEqual(["apple", "banana", "cactus"]);
+    });
+
+    test("Testing the stringsToIntegers function", () => {
+        expect(stringsToIntegers(VALUES_1)).toEqual([1, 2, 3]);
+        expect(stringsToIntegers(VALUES_2)).toEqual([100, 200, 300]);
+        expect(stringsToIntegers(VALUES_3)).toEqual([5]);
+        expect(stringsToIntegers(VALUES_4)).toEqual([]);
+        expect(stringsToIntegers(VALUES_5)).toEqual([100, 0, 27, 0]);
+        expect(stringsToIntegers(VALUES_6)).toEqual([-1, 0, 1, 0]);
+        expect(stringsToIntegers(VALUES_7)).toEqual([0, 0, 0]);
+    });
+
+    //////////////////////////////////
+    // removeDollars
+
+    const AMOUNTS_1 = ["$1", "$2", "$3"];
+    const AMOUNTS_2 = ["$100", "$200", "$300", "$400"];
+    const AMOUNTS_3 = ["$5"];
+    const AMOUNTS_4 = ["$"];
+    const AMOUNTS_5 = ["100", "200", "$300", "$400"];
+    const AMOUNTS_6: string[] = [];
+    const AMOUNTS_7 = ["100", "???", "7", "$233", "", "$"];
+    const AMOUNTS_8 = ["$one", "two", "$three"];
+
+    // Ensure that none of the arrays were changed mutably
+    // If you fail these, you aren't using map/filter/reduce/etc. properly!
+    afterEach(() => {
+        expect(AMOUNTS_1).toEqual(["$1", "$2", "$3"]);
+        expect(AMOUNTS_2).toEqual(["$100", "$200", "$300", "$400"]);
+        expect(AMOUNTS_3).toEqual(["$5"]);
+        expect(AMOUNTS_4).toEqual(["$"]);
+        expect(AMOUNTS_5).toEqual(["100", "200", "$300", "$400"]);
+        expect(AMOUNTS_6).toEqual([]);
+        expect(AMOUNTS_7).toEqual(["100", "???", "7", "$233", "", "$"]);
+        expect(AMOUNTS_8).toEqual(["$one", "two", "$three"]);
+    });
+
+    test("Testing the removeDollars function", () => {
+        expect(removeDollars(AMOUNTS_1)).toEqual([1, 2, 3]);
+        expect(removeDollars(AMOUNTS_2)).toEqual([100, 200, 300, 400]);
+        expect(removeDollars(AMOUNTS_3)).toEqual([5]);
+        expect(removeDollars(AMOUNTS_4)).toEqual([0]);
+        expect(removeDollars(AMOUNTS_5)).toEqual([100, 200, 300, 400]);
+        expect(removeDollars(AMOUNTS_6)).toEqual([]);
+        expect(removeDollars(AMOUNTS_7)).toEqual([100, 0, 7, 233, 0, 0]);
+        expect(removeDollars(AMOUNTS_8)).toEqual([0, 0, 0]);
+    });
+
+    //////////////////////////////////
+    // shoutIfExclaiming
+
+    const MESSAGE_1 = ["Hello", "you", "are", "great!"];
+    const MESSAGE_2 = ["oho!", "Oho!", "oHo!", "oHO!", "OHO!"];
+    const MESSAGE_3 = ["Wait?", "What?", "Lo", "How?", "High!"];
+    const MESSAGE_4 = ["??????"];
+    const MESSAGE_5: string[] = ["This one is very long!"];
+    const MESSAGE_6 = ["No", "Caps", "here.", "Right?"];
+
+    // Ensure that none of the arrays were changed mutably
+    // If you fail these, you aren't using map/filter/reduce/etc. properly!
+    afterEach(() => {
+        expect(MESSAGE_1).toEqual(["Hello", "you", "are", "great!"]);
+        expect(MESSAGE_2).toEqual(["oho!", "Oho!", "oHo!", "oHO!", "OHO!"]);
+        expect(MESSAGE_3).toEqual(["Wait?", "What?", "Lo", "How?", "High!"]);
+        expect(MESSAGE_4).toEqual(["??????"]);
+        expect(MESSAGE_5).toEqual(["This one is very long!"]);
+        expect(MESSAGE_6).toEqual(["No", "Caps", "here.", "Right?"]);
+    });
+
+    test("Testing the shoutIfExclaiming function", () => {
+        expect(shoutIfExclaiming(MESSAGE_1)).toEqual([
+            "Hello",
+            "you",
+            "are",
+            "GREAT!"
+        ]);
+        expect(shoutIfExclaiming(MESSAGE_2)).toEqual([
+            "OHO!",
+            "OHO!",
+            "OHO!",
+            "OHO!",
+            "OHO!"
+        ]);
+        expect(shoutIfExclaiming(MESSAGE_3)).toEqual(["Lo", "HIGH!"]);
+        expect(shoutIfExclaiming(MESSAGE_4)).toEqual([]);
+        expect(shoutIfExclaiming(MESSAGE_5)).toEqual([
+            "THIS ONE IS VERY LONG!"
+        ]);
+        expect(shoutIfExclaiming(MESSAGE_6)).toEqual(["No", "Caps", "here."]);
+    });
+
+    //////////////////////////////////
+    // countShortWords
+
+    const WORDS_1 = ["the", "cat", "in", "the", "hat"];
+    const WORDS_2 = ["one", "two", "three", "four", "five", "six", "seven"];
+    const WORDS_3 = ["alpha", "beta", "gamma"];
+    const WORDS_4 = ["Longest", "Words", "Possible"];
+    const WORDS_5: string[] = [];
+    const WORDS_6 = ["", "", "", ""];
+
+    // Ensure that none of the arrays were changed mutably
+    // If you fail these, you aren't using map/filter/reduce/etc. properly!
+    afterEach(() => {
+        expect(WORDS_1).toEqual(["the", "cat", "in", "the", "hat"]);
+        expect(WORDS_2).toEqual([
+            "one",
+            "two",
+            "three",
+            "four",
+            "five",
+            "six",
+            "seven"
+        ]);
+        expect(WORDS_3).toEqual(["alpha", "beta", "gamma"]);
+        expect(WORDS_4).toEqual(["Longest", "Words", "Possible"]);
+        expect(WORDS_5).toEqual([]);
+        expect(WORDS_6).toEqual(["", "", "", ""]);
+    });
+
+    test("Testing the countShortWords function", () => {
+        expect(countShortWords(WORDS_1)).toEqual(5);
+        expect(countShortWords(WORDS_2)).toEqual(3);
+        expect(countShortWords(WORDS_3)).toEqual(0);
+        expect(countShortWords(WORDS_4)).toEqual(0);
+        expect(countShortWords(WORDS_5)).toEqual(0);
+        expect(countShortWords(WORDS_6)).toEqual(4);
+    });
+
+    //////////////////////////////////
+    // allRGB
+
+    const COLORS_1 = ["red", "green", "blue"];
+    const COLORS_2 = ["red", "red", "red"];
+    const COLORS_3 = ["red", "red", "blue", "blue", "green", "red"];
+    const COLORS_4 = ["purple", "orange", "violet"];
+    const COLORS_5 = ["red", "blue", "yellow"];
+    const COLORS_6 = ["green"];
+    const COLORS_7 = ["red"];
+    const COLORS_8 = ["kabluey"];
+    const COLORS_9: string[] = [];
+
+    // Ensure that none of the arrays were changed mutably
+    // If you fail these, you aren't using map/filter/reduce/etc. properly!
+    afterEach(() => {
+        expect(COLORS_1).toEqual(["red", "green", "blue"]);
+        expect(COLORS_2).toEqual(["red", "red", "red"]);
+        expect(COLORS_3).toEqual([
+            "red",
+            "red",
+            "blue",
+            "blue",
+            "green",
+            "red"
+        ]);
+        expect(COLORS_4).toEqual(["purple", "orange", "violet"]);
+        expect(COLORS_5).toEqual(["red", "blue", "yellow"]);
+        expect(COLORS_6).toEqual(["green"]);
+        expect(COLORS_7).toEqual(["red"]);
+        expect(COLORS_8).toEqual(["kabluey"]);
+        expect(COLORS_9).toEqual([]);
+    });
+
+    test("Testing the allRGB function", () => {
+        expect(allRGB(COLORS_1)).toEqual(true);
+        expect(allRGB(COLORS_2)).toEqual(true);
+        expect(allRGB(COLORS_3)).toEqual(true);
+        expect(allRGB(COLORS_4)).toEqual(false);
+        expect(allRGB(COLORS_5)).toEqual(false);
+        expect(allRGB(COLORS_6)).toEqual(true);
+        expect(allRGB(COLORS_7)).toEqual(true);
+        expect(allRGB(COLORS_8)).toEqual(false);
+        expect(allRGB(COLORS_9)).toEqual(true);
+    });
+
+    //////////////////////////////////
+    // makeMath
+
+    test("Testing the makeMath function", () => {
+        expect(makeMath(NUMBERS_1)).toEqual("6=1+2+3");
+        expect(makeMath(NUMBERS_2)).toEqual("600=100+300+200");
+        expect(makeMath(NUMBERS_3)).toEqual("5=5");
+        expect(makeMath(NUMBERS_4)).toEqual("0=0");
+        expect(makeMath(NUMBERS_7)).toEqual("1000=199+1+550+50+200");
+    });
+
+    //////////////////////////////////
+    // injectPositive
+    test("Testing the tripleNumbers function", () => {
+        expect(injectPositive(NUMBERS_1)).toEqual([1, 2, 3, 6]);
+        expect(injectPositive(NUMBERS_2)).toEqual([100, 300, 200, 600]);
+        expect(injectPositive(NUMBERS_3)).toEqual([5, 5]);
+        expect(injectPositive(NUMBERS_4)).toEqual([0]);
+        expect(injectPositive(NUMBERS_5)).toEqual([100, 199, 1, -5, 300, 7, 3]);
+        expect(injectPositive(NUMBERS_6)).toEqual([-100, 0, -200, 100, 200]);
+        expect(injectPositive(NUMBERS_7)).toEqual([199, 1, 550, 50, 200, 1000]);
     });
 });

From b8777b1873553a2e2780b67fd504486b9d16bd92 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Tue, 1 Feb 2022 16:09:25 -0500
Subject: [PATCH 20/46] Fix question text

---
 src/arrays.ts | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/arrays.ts b/src/arrays.ts
index 7604b40cdb..4a2ffe8e5b 100644
--- a/src/arrays.ts
+++ b/src/arrays.ts
@@ -18,7 +18,7 @@ export function tripleNumbers(numbers: number[]): number[] {
 
 /**
  * Consume an array of strings and convert them to integers. If
- * the number cannot be parsed as an integer, convert it to "?" instead.
+ * the number cannot be parsed as an integer, convert it to 0 instead.
  */
 export function stringsToIntegers(numbers: string[]): number[] {
     return [];
@@ -28,7 +28,7 @@ export function stringsToIntegers(numbers: string[]): number[] {
  * Consume an array of strings and return them as numbers. Note that
  * the strings MAY have "$" symbols at the beginning, in which case
  * those should be removed. If the result cannot be parsed as an integer,
- * convert it to "?" instead.
+ * convert it to 0 instead.
  */
 // Remember, you can write functions as lambdas too! They work exactly the same.
 export const removeDollars = (amounts: string[]): number[] => {
@@ -37,7 +37,8 @@ export const removeDollars = (amounts: string[]): number[] => {
 
 /**
  * Consume an array of messages and return a new list of the messages. However, any
- * string that ends in "!" should be made uppercase.
+ * string that ends in "!" should be made uppercase. Also, remove any strings that end
+ * in question marks ("?").
  */
 export const shoutIfExclaiming = (messages: string[]): string[] => {
     return [];
@@ -65,6 +66,7 @@ export function allRGB(colors: string[]): boolean {
  * numbers being added together along with their actual sum.
  *
  * For instance, the array [1, 2, 3] would become "6=1+2+3".
+ * And the array [] would become "0=0".
  */
 export function makeMath(addends: number[]): string {
     return "";
@@ -74,10 +76,10 @@ export function makeMath(addends: number[]): string {
  * Consumes an array of numbers and produces a new array of the same numbers,
  * with one difference. After the FIRST negative number, insert the sum of all
  * previous numbers in the list. If there are no negative numbers, then append
- * 0 to the list.
+ * the sum to the list.
  *
  * For instance, the array [1, 9, -5, 7] would become [1, 9, -5, 10, 7]
- * And the array [1, 9, 7] would become [1, 9, 0]
+ * And the array [1, 9, 7] would become [1, 9, 7, 17]
  */
 export function injectPositive(values: number[]): number[] {
     return [];

From f87771e7d8058f6c4fc6d8c6d036953f65b3a775 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Fri, 11 Feb 2022 14:24:17 -0500
Subject: [PATCH 21/46] Update arrays.test.ts

---
 src/arrays.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/arrays.test.ts b/src/arrays.test.ts
index 0881d9fe8a..3652078efa 100644
--- a/src/arrays.test.ts
+++ b/src/arrays.test.ts
@@ -261,7 +261,7 @@ describe("Testing the array functions", () => {
 
     //////////////////////////////////
     // injectPositive
-    test("Testing the tripleNumbers function", () => {
+    test("Testing the injectPositive function", () => {
         expect(injectPositive(NUMBERS_1)).toEqual([1, 2, 3, 6]);
         expect(injectPositive(NUMBERS_2)).toEqual([100, 300, 200, 600]);
         expect(injectPositive(NUMBERS_3)).toEqual([5, 5]);

From f0d316b36ae394d502e75849b5532b76ffdf7c68 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sat, 24 Aug 2024 13:21:13 -0400
Subject: [PATCH 22/46] Add in points

---
 src/arrays.test.ts | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/arrays.test.ts b/src/arrays.test.ts
index 3652078efa..c2847517bd 100644
--- a/src/arrays.test.ts
+++ b/src/arrays.test.ts
@@ -7,7 +7,7 @@ import {
     removeDollars,
     shoutIfExclaiming,
     stringsToIntegers,
-    tripleNumbers
+    tripleNumbers,
 } from "./arrays";
 
 describe("Testing the array functions", () => {
@@ -34,7 +34,7 @@ describe("Testing the array functions", () => {
         expect(NUMBERS_7).toEqual([199, 1, 550, 50, 200]);
     });
 
-    test("Testing the bookEndList function", () => {
+    test("(3 pts) Testing the bookEndList function", () => {
         expect(bookEndList(NUMBERS_1)).toEqual([1, 3]);
         expect(bookEndList(NUMBERS_2)).toEqual([100, 200]);
         expect(bookEndList(NUMBERS_3)).toEqual([5, 5]);
@@ -43,7 +43,7 @@ describe("Testing the array functions", () => {
         expect(bookEndList(NUMBERS_6)).toEqual([-100, 200]);
     });
 
-    test("Testing the tripleNumbers function", () => {
+    test("(3 pts) Testing the tripleNumbers function", () => {
         expect(tripleNumbers(NUMBERS_1)).toEqual([3, 6, 9]);
         expect(tripleNumbers(NUMBERS_2)).toEqual([300, 900, 600]);
         expect(tripleNumbers(NUMBERS_3)).toEqual([15]);
@@ -75,7 +75,7 @@ describe("Testing the array functions", () => {
         expect(VALUES_7).toEqual(["apple", "banana", "cactus"]);
     });
 
-    test("Testing the stringsToIntegers function", () => {
+    test("(3 pts) Testing the stringsToIntegers function", () => {
         expect(stringsToIntegers(VALUES_1)).toEqual([1, 2, 3]);
         expect(stringsToIntegers(VALUES_2)).toEqual([100, 200, 300]);
         expect(stringsToIntegers(VALUES_3)).toEqual([5]);
@@ -110,7 +110,7 @@ describe("Testing the array functions", () => {
         expect(AMOUNTS_8).toEqual(["$one", "two", "$three"]);
     });
 
-    test("Testing the removeDollars function", () => {
+    test("(3 pts) Testing the removeDollars function", () => {
         expect(removeDollars(AMOUNTS_1)).toEqual([1, 2, 3]);
         expect(removeDollars(AMOUNTS_2)).toEqual([100, 200, 300, 400]);
         expect(removeDollars(AMOUNTS_3)).toEqual([5]);
@@ -142,24 +142,24 @@ describe("Testing the array functions", () => {
         expect(MESSAGE_6).toEqual(["No", "Caps", "here.", "Right?"]);
     });
 
-    test("Testing the shoutIfExclaiming function", () => {
+    test("(3 pts) Testing the shoutIfExclaiming function", () => {
         expect(shoutIfExclaiming(MESSAGE_1)).toEqual([
             "Hello",
             "you",
             "are",
-            "GREAT!"
+            "GREAT!",
         ]);
         expect(shoutIfExclaiming(MESSAGE_2)).toEqual([
             "OHO!",
             "OHO!",
             "OHO!",
             "OHO!",
-            "OHO!"
+            "OHO!",
         ]);
         expect(shoutIfExclaiming(MESSAGE_3)).toEqual(["Lo", "HIGH!"]);
         expect(shoutIfExclaiming(MESSAGE_4)).toEqual([]);
         expect(shoutIfExclaiming(MESSAGE_5)).toEqual([
-            "THIS ONE IS VERY LONG!"
+            "THIS ONE IS VERY LONG!",
         ]);
         expect(shoutIfExclaiming(MESSAGE_6)).toEqual(["No", "Caps", "here."]);
     });
@@ -185,7 +185,7 @@ describe("Testing the array functions", () => {
             "four",
             "five",
             "six",
-            "seven"
+            "seven",
         ]);
         expect(WORDS_3).toEqual(["alpha", "beta", "gamma"]);
         expect(WORDS_4).toEqual(["Longest", "Words", "Possible"]);
@@ -193,7 +193,7 @@ describe("Testing the array functions", () => {
         expect(WORDS_6).toEqual(["", "", "", ""]);
     });
 
-    test("Testing the countShortWords function", () => {
+    test("(3 pts) Testing the countShortWords function", () => {
         expect(countShortWords(WORDS_1)).toEqual(5);
         expect(countShortWords(WORDS_2)).toEqual(3);
         expect(countShortWords(WORDS_3)).toEqual(0);
@@ -226,7 +226,7 @@ describe("Testing the array functions", () => {
             "blue",
             "blue",
             "green",
-            "red"
+            "red",
         ]);
         expect(COLORS_4).toEqual(["purple", "orange", "violet"]);
         expect(COLORS_5).toEqual(["red", "blue", "yellow"]);
@@ -236,7 +236,7 @@ describe("Testing the array functions", () => {
         expect(COLORS_9).toEqual([]);
     });
 
-    test("Testing the allRGB function", () => {
+    test("(3 pts) Testing the allRGB function", () => {
         expect(allRGB(COLORS_1)).toEqual(true);
         expect(allRGB(COLORS_2)).toEqual(true);
         expect(allRGB(COLORS_3)).toEqual(true);
@@ -251,7 +251,7 @@ describe("Testing the array functions", () => {
     //////////////////////////////////
     // makeMath
 
-    test("Testing the makeMath function", () => {
+    test("(3 pts) Testing the makeMath function", () => {
         expect(makeMath(NUMBERS_1)).toEqual("6=1+2+3");
         expect(makeMath(NUMBERS_2)).toEqual("600=100+300+200");
         expect(makeMath(NUMBERS_3)).toEqual("5=5");
@@ -261,7 +261,7 @@ describe("Testing the array functions", () => {
 
     //////////////////////////////////
     // injectPositive
-    test("Testing the injectPositive function", () => {
+    test("(3 pts) Testing the injectPositive function", () => {
         expect(injectPositive(NUMBERS_1)).toEqual([1, 2, 3, 6]);
         expect(injectPositive(NUMBERS_2)).toEqual([100, 300, 200, 600]);
         expect(injectPositive(NUMBERS_3)).toEqual([5, 5]);

From c2e556dece7ea7737c13bdd355ef3ebcee121e70 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Wed, 2 Feb 2022 13:12:40 -0500
Subject: [PATCH 23/46] First stab at questions

---
 public/tasks/task-objects.md |   5 +
 src/data/questions.json      |  79 ++++++++++
 src/objects.test.ts          | 295 +++++++++++++++++++++++++++++++++++
 src/objects.ts               | 141 +++++++++++++++++
 4 files changed, 520 insertions(+)
 create mode 100644 public/tasks/task-objects.md
 create mode 100644 src/data/questions.json
 create mode 100644 src/objects.test.ts
 create mode 100644 src/objects.ts

diff --git a/public/tasks/task-objects.md b/public/tasks/task-objects.md
new file mode 100644
index 0000000000..480889da0d
--- /dev/null
+++ b/public/tasks/task-objects.md
@@ -0,0 +1,5 @@
+# Task - Objects
+
+Version: 0.0.1
+
+Implement functions that work with objects immutably.
diff --git a/src/data/questions.json b/src/data/questions.json
new file mode 100644
index 0000000000..3b19537526
--- /dev/null
+++ b/src/data/questions.json
@@ -0,0 +1,79 @@
+{
+    "BLANK_QUESTIONS": [
+        {
+            "id": 1,
+            "name": "Question 1",
+            "body": "",
+            "type": "multiple_choice_question",
+            "options": [],
+            "expected": "",
+            "points": 1,
+            "published": false
+        },
+        {
+            "id": 47,
+            "name": "My New Question",
+            "body": "",
+            "type": "multiple_choice_question",
+            "options": [],
+            "expected": "",
+            "points": 1,
+            "published": false
+        },
+        {
+            "id": 2,
+            "name": "Question 2",
+            "body": "",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "",
+            "points": 1,
+            "published": false
+        }
+    ],
+    "SIMPLE_QUESTIONS": [
+        {
+            "id": 1,
+            "name": "Addition",
+            "body": "What is 2+2?",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "4",
+            "points": 1,
+            "published": true
+        },
+        {
+            "id": 2,
+            "name": "Letters",
+            "body": "What is the last letter of the English alphabet?",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "Z",
+            "points": 1,
+            "published": false
+        },
+        {
+            "id": 5,
+            "name": "Colors",
+            "body": "Which of these is a color?",
+            "type": "multiple_choice_question",
+            "options": ["red", "apple", "firetruck"],
+            "expected": "red",
+            "points": 1,
+            "published": true
+        },
+        {
+            "id": 9,
+            "name": "Shapes",
+            "body": "What shape can you make with one line?",
+            "type": "multiple_choice_question",
+            "options": ["square", "triangle", "circle"],
+            "expected": "circle",
+            "points": 2,
+            "published": false
+        }
+    ],
+    "SIMPLE_QUESTIONS_2": [],
+    "EMPTY_QUESTIONS": [],
+    "TRIVIA_QUESTIONS": []
+}
diff --git a/src/objects.test.ts b/src/objects.test.ts
new file mode 100644
index 0000000000..bcff7ab176
--- /dev/null
+++ b/src/objects.test.ts
@@ -0,0 +1,295 @@
+import {
+    makeBlankQuestion,
+    isCorrect,
+    Question,
+    isValid,
+    toShortForm,
+    toMarkdown,
+    duplicateQuestion,
+    renameQuestion,
+    publishQuestion,
+    addOption,
+    mergeQuestion
+} from "./objects";
+import testQuestionData from "./data/questions.json";
+import backupQuestionData from "./data/questions.json";
+
+////////////////////////////////////////////
+// Setting up the test data
+
+const { BLANK_QUESTIONS, SIMPLE_QUESTIONS }: Record<string, Question[]> =
+    // Typecast the test data that we imported to be a record matching
+    //  strings to the question list
+    testQuestionData as Record<string, Question[]>;
+
+// We have backup versions of the data to make sure all changes are immutable
+const {
+    BLANK_QUESTIONS: BACKUP_BLANK_QUESTIONS,
+    SIMPLE_QUESTIONS: BACKUP_SIMPLE_QUESTIONS
+}: Record<string, Question[]> = backupQuestionData as Record<
+    string,
+    Question[]
+>;
+
+// Unpack the list of simple questions into convenient constants
+const [ADDITION_QUESTION, LETTER_QUESTION, COLOR_QUESTION, SHAPE_QUESTION] =
+    SIMPLE_QUESTIONS;
+const [
+    BACKUP_ADDITION_QUESTION,
+    BACKUP_LETTER_QUESTION,
+    BACKUP_COLOR_QUESTION,
+    BACKUP_SHAPE_QUESTION
+] = BACKUP_SIMPLE_QUESTIONS;
+
+////////////////////////////////////////////
+// Actual tests
+
+describe("Testing the object functions", () => {
+    //////////////////////////////////
+    // makeBlankQuestion
+
+    test("Testing the makeBlankQuestion function", () => {
+        expect(
+            makeBlankQuestion(1, "Question 1", "multiple_choice_question")
+        ).toEqual(BLANK_QUESTIONS[0]);
+        expect(
+            makeBlankQuestion(47, "My New Question", "multiple_choice_question")
+        ).toEqual(BLANK_QUESTIONS[1]);
+        expect(
+            makeBlankQuestion(2, "Question 2", "short_answer_question")
+        ).toEqual(BLANK_QUESTIONS[2]);
+    });
+
+    ///////////////////////////////////
+    // isCorrect
+    test("Testing the isCorrect function", () => {
+        expect(isCorrect(ADDITION_QUESTION, "4")).toEqual(true);
+        expect(isCorrect(ADDITION_QUESTION, "2")).toEqual(false);
+        expect(isCorrect(ADDITION_QUESTION, " 4\n")).toEqual(true);
+        expect(isCorrect(LETTER_QUESTION, "Z")).toEqual(true);
+        expect(isCorrect(LETTER_QUESTION, "z")).toEqual(true);
+        expect(isCorrect(LETTER_QUESTION, "4")).toEqual(false);
+        expect(isCorrect(LETTER_QUESTION, "0")).toEqual(false);
+        expect(isCorrect(LETTER_QUESTION, "zed")).toEqual(false);
+        expect(isCorrect(COLOR_QUESTION, "red")).toEqual(true);
+        expect(isCorrect(COLOR_QUESTION, "apple")).toEqual(false);
+        expect(isCorrect(COLOR_QUESTION, "firetruck")).toEqual(false);
+        expect(isCorrect(SHAPE_QUESTION, "square")).toEqual(false);
+        expect(isCorrect(SHAPE_QUESTION, "triangle")).toEqual(false);
+        expect(isCorrect(SHAPE_QUESTION, "circle")).toEqual(true);
+    });
+
+    ///////////////////////////////////
+    // isValid
+    test("Testing the isValid function", () => {
+        expect(isValid(ADDITION_QUESTION, "4")).toEqual(true);
+        expect(isValid(ADDITION_QUESTION, "2")).toEqual(true);
+        expect(isValid(ADDITION_QUESTION, " 4\n")).toEqual(true);
+        expect(isValid(LETTER_QUESTION, "Z")).toEqual(true);
+        expect(isValid(LETTER_QUESTION, "z")).toEqual(true);
+        expect(isValid(LETTER_QUESTION, "4")).toEqual(true);
+        expect(isValid(LETTER_QUESTION, "0")).toEqual(true);
+        expect(isValid(LETTER_QUESTION, "zed")).toEqual(true);
+        expect(isValid(COLOR_QUESTION, "red")).toEqual(true);
+        expect(isValid(COLOR_QUESTION, "apple")).toEqual(true);
+        expect(isValid(COLOR_QUESTION, "firetruck")).toEqual(true);
+        expect(isValid(COLOR_QUESTION, "RED")).toEqual(false);
+        expect(isValid(COLOR_QUESTION, "orange")).toEqual(false);
+        expect(isValid(SHAPE_QUESTION, "square")).toEqual(true);
+        expect(isValid(SHAPE_QUESTION, "triangle")).toEqual(true);
+        expect(isValid(SHAPE_QUESTION, "circle")).toEqual(true);
+        expect(isValid(SHAPE_QUESTION, "circle ")).toEqual(false);
+        expect(isValid(SHAPE_QUESTION, "rhombus")).toEqual(false);
+    });
+
+    ///////////////////////////////////
+    // toShortForm
+    test("Testing the toShortForm function", () => {
+        expect(toShortForm(ADDITION_QUESTION)).toEqual("1: Addition");
+        expect(toShortForm(LETTER_QUESTION)).toEqual("2: Letters");
+        expect(toShortForm(COLOR_QUESTION)).toEqual("5: Colors");
+        expect(toShortForm(SHAPE_QUESTION)).toEqual("9: Shapes");
+        expect(toShortForm(BLANK_QUESTIONS[1])).toEqual("47: My New Que");
+    });
+
+    ///////////////////////////////////
+    // toMarkdown
+    test("Testing the toMarkdown function", () => {
+        expect(toMarkdown(ADDITION_QUESTION)).toEqual(`# Addition
+What is 2+2?`);
+        expect(toMarkdown(LETTER_QUESTION)).toEqual(`# Letters
+What is the last letter of the English alphabet?`);
+        expect(toMarkdown(COLOR_QUESTION)).toEqual(`# Colors
+Which of these is a color?
+- red
+- apple
+- firetruck`);
+        expect(toMarkdown(SHAPE_QUESTION)).toEqual(`# Shapes
+What shape can you make with one line?
+- square
+- triangle
+- circle`);
+    });
+
+    afterEach(() => {
+        expect(ADDITION_QUESTION).toEqual(BACKUP_ADDITION_QUESTION);
+        expect(LETTER_QUESTION).toEqual(BACKUP_LETTER_QUESTION);
+        expect(SHAPE_QUESTION).toEqual(BACKUP_SHAPE_QUESTION);
+        expect(COLOR_QUESTION).toEqual(BACKUP_COLOR_QUESTION);
+        expect(BLANK_QUESTIONS).toEqual(BACKUP_BLANK_QUESTIONS);
+    });
+
+    ///////////////////////////////////
+    // renameQuestion
+    test("Testing the renameQuestion function", () => {
+        expect(
+            renameQuestion(ADDITION_QUESTION, "My Addition Question")
+        ).toEqual({
+            id: 1,
+            name: "My Addition Question",
+            body: "What is 2+2?",
+            type: "short_answer_question",
+            options: [],
+            expected: "4",
+            points: 1,
+            published: true
+        });
+        expect(
+            renameQuestion(SHAPE_QUESTION, "I COMPLETELY CHANGED THIS NAME")
+        ).toEqual({
+            id: 9,
+            name: "I COMPLETELY CHANGED THIS NAME",
+            body: "What shape can you make with one line?",
+            type: "multiple_choice_question",
+            options: ["square", "triangle", "circle"],
+            expected: "circle",
+            points: 2,
+            published: false
+        });
+    });
+
+    ///////////////////////////////////
+    // publishQuestion
+    test("Testing the publishQuestion function", () => {
+        expect(publishQuestion(ADDITION_QUESTION)).toEqual({
+            id: 1,
+            name: "Addition",
+            body: "What is 2+2?",
+            type: "short_answer_question",
+            options: [],
+            expected: "4",
+            points: 1,
+            published: false
+        });
+        expect(publishQuestion(LETTER_QUESTION)).toEqual({
+            id: 2,
+            name: "Letters",
+            body: "What is the last letter of the English alphabet?",
+            type: "short_answer_question",
+            options: [],
+            expected: "Z",
+            points: 1,
+            published: true
+        });
+        expect(publishQuestion(publishQuestion(ADDITION_QUESTION))).toEqual({
+            id: 1,
+            name: "Addition",
+            body: "What is 2+2?",
+            type: "short_answer_question",
+            options: [],
+            expected: "4",
+            points: 1,
+            published: true
+        });
+    });
+
+    ///////////////////////////////////
+    // duplicateQuestion
+    test("Testing the duplicateQuestion function", () => {
+        expect(duplicateQuestion(9, ADDITION_QUESTION)).toEqual({
+            id: 9,
+            name: "Copy of Addition",
+            body: "What is 2+2?",
+            type: "short_answer_question",
+            options: [],
+            expected: "4",
+            points: 1,
+            published: false
+        });
+        expect(duplicateQuestion(55, LETTER_QUESTION)).toEqual({
+            id: 55,
+            name: "Copy of Letters",
+            body: "What is the last letter of the English alphabet?",
+            type: "short_answer_question",
+            options: [],
+            expected: "Z",
+            points: 1,
+            published: false
+        });
+    });
+
+    ///////////////////////////////////
+    // addOption
+    test("Testing the addOption function", () => {
+        expect(addOption(SHAPE_QUESTION, "heptagon")).toEqual({
+            id: 9,
+            name: "Shapes",
+            body: "What shape can you make with one line?",
+            type: "multiple_choice_question",
+            options: ["square", "triangle", "circle", "heptagon"],
+            expected: "circle",
+            points: 2,
+            published: false
+        });
+        expect(addOption(COLOR_QUESTION, "squiggles")).toEqual({
+            id: 5,
+            name: "Colors",
+            body: "Which of these is a color?",
+            type: "multiple_choice_question",
+            options: ["red", "apple", "firetruck", "squiggles"],
+            expected: "red",
+            points: 1,
+            published: true
+        });
+    });
+
+    ///////////////////////////////////
+    // mergeQuestion
+    test("Testing the mergeQuestion function", () => {
+        expect(
+            mergeQuestion(
+                192,
+                "More Points Addition",
+                ADDITION_QUESTION,
+                SHAPE_QUESTION
+            )
+        ).toEqual({
+            id: 192,
+            name: "More Points Addition",
+            body: "What is 2+2?",
+            type: "short_answer_question",
+            options: [],
+            expected: "4",
+            points: 2,
+            published: false
+        });
+
+        expect(
+            mergeQuestion(
+                99,
+                "Less Points Shape",
+                SHAPE_QUESTION,
+                ADDITION_QUESTION
+            )
+        ).toEqual({
+            id: 99,
+            name: "Less Points Shape",
+            body: "What shape can you make with one line?",
+            type: "multiple_choice_question",
+            options: ["square", "triangle", "circle"],
+            expected: "circle",
+            points: 1,
+            published: false
+        });
+    });
+});
diff --git a/src/objects.ts b/src/objects.ts
new file mode 100644
index 0000000000..d03dd473e3
--- /dev/null
+++ b/src/objects.ts
@@ -0,0 +1,141 @@
+/** QuestionType influences how a question is asked and what kinds of answers are possible */
+export type QuestionType = "multiple_choice_question" | "short_answer_question";
+
+export interface Question {
+    /** A unique identifier for the question */
+    id: number;
+    /** The human-friendly title of the question */
+    name: string;
+    /** The instructions and content of the Question */
+    body: string;
+    /** The kind of Question; influences how the user answers and what options are displayed */
+    type: QuestionType;
+    /** The possible answers for a Question (for Multiple Choice questions) */
+    options: string[];
+    /** The actually correct answer expected */
+    expected: string;
+    /** How many points this question is worth, roughly indicating its importance and difficulty */
+    points: number;
+    /** Whether or not this question is ready to display to students */
+    published: boolean;
+}
+
+/**
+ * Create a new blank question with the given `id`, `name`, and `type. The `body` and
+ * `expected` should be empty strings, the `options` should be an empty list, the `points`
+ * should default to 1, and `published` should default to false.
+ */
+export function makeBlankQuestion(
+    id: number,
+    name: string,
+    type: QuestionType
+): Question {
+    return {};
+}
+
+/**
+ * Consumes a question and a potential `answer`, and returns whether or not
+ * the `answer` is correct. You should check that the `answer` is equal to
+ * the `expected`, ignoring capitalization and trimming any whitespace.
+ *
+ * HINT: Look up the `trim` and `toLowerCase` functions.
+ */
+export function isCorrect(question: Question, answer: string): boolean {
+    return false;
+}
+
+/**
+ * Consumes a question and a potential `answer`, and returns whether or not
+ * the `answer` is valid (but not necessarily correct). For a `short_answer_question`,
+ * any answer is valid. But for a `multiple_choice_question`, the `answer` must
+ * be exactly one of the options.
+ */
+export function isValid(question: Question, answer: string): boolean {
+    return false;
+}
+
+/**
+ * Consumes a question and produces a string representation combining the
+ * `id` and first 10 characters of the `name`. The two strings should be
+ * separated by ": ". So for example, the question with id 9 and the
+ * name "My First Question" would become "9: My First Q".
+ */
+export function toShortForm(question: Question): string {
+    return "";
+}
+
+/**
+ * Consumes a question and returns a formatted string representation as follows:
+ *  - The first line should be a hash sign, a space, and then the `name`
+ *  - The second line should be the `body`
+ *  - If the question is a `multiple_choice_question`, then the following lines
+ *      need to show each option on its line, preceded by a dash and space.
+ *
+ * The example below might help, but don't include the border!
+ * ----------Example-------------
+ * |# Name                      |
+ * |The body goes here!         |
+ * |- Option 1                  |
+ * |- Option 2                  |
+ * |- Option 3                  |
+ * ------------------------------
+ * Check the unit tests for more examples of what this looks like!
+ */
+export function toMarkdown(question: Question): string {
+    return "";
+}
+
+/**
+ * Return a new version of the given question, except the name should now be
+ * `newName`.
+ */
+export function renameQuestion(question: Question, newName: string): Question {
+    return question;
+}
+
+/**
+ * Return a new version of the given question, except the `published` field
+ * should be inverted. If the question was not published, now it should be
+ * published; if it was published, now it should be not published.
+ */
+export function publishQuestion(question: Question): Question {
+    return question;
+}
+
+/**
+ * Create a new question based on the old question, copying over its `body`, `type`,
+ * `options`, `expected`, and `points` without changes. The `name` should be copied
+ * over as "Copy of ORIGINAL NAME" (e.g., so "Question 1" would become "Copy of Question 1").
+ * The `published` field should be reset to false.
+ */
+export function duplicateQuestion(id: number, oldQuestion: Question): Question {
+    return oldQuestion;
+}
+
+/**
+ * Return a new version of the given question, with the `newOption` added to
+ * the list of existing `options`. Remember that the new Question MUST have
+ * its own separate copy of the `options` list, rather than the same reference
+ * to the original question's list!
+ * Check out the subsection about "Nested Fields" for more information.
+ */
+export function addOption(question: Question, newOption: string): Question {
+    return question;
+}
+
+/**
+ * Consumes an id, name, and two questions, and produces a new question.
+ * The new question will use the `body`, `type`, `options`, and `expected` of the
+ * `contentQuestion`. The second question will provide the `points`.
+ * The `published` status should be set to false.
+ * Notice that the second Question is provided as just an object with a `points`
+ * field; but the function call would be the same as if it were a `Question` type!
+ */
+export function mergeQuestion(
+    id: number,
+    name: string,
+    contentQuestion: Question,
+    { points }: { points: number }
+): Question {
+    return contentQuestion;
+}

From 406ffb2b572cb14e885af2a2fddc8e9cc42c97dd Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sun, 6 Feb 2022 18:33:46 -0500
Subject: [PATCH 24/46] Move Question interface to separate file

---
 src/interfaces/question.ts | 21 +++++++++++++++++++++
 src/objects.test.ts        |  2 +-
 src/objects.ts             | 22 +---------------------
 3 files changed, 23 insertions(+), 22 deletions(-)
 create mode 100644 src/interfaces/question.ts

diff --git a/src/interfaces/question.ts b/src/interfaces/question.ts
new file mode 100644
index 0000000000..a39431565e
--- /dev/null
+++ b/src/interfaces/question.ts
@@ -0,0 +1,21 @@
+/** QuestionType influences how a question is asked and what kinds of answers are possible */
+export type QuestionType = "multiple_choice_question" | "short_answer_question";
+
+export interface Question {
+    /** A unique identifier for the question */
+    id: number;
+    /** The human-friendly title of the question */
+    name: string;
+    /** The instructions and content of the Question */
+    body: string;
+    /** The kind of Question; influences how the user answers and what options are displayed */
+    type: QuestionType;
+    /** The possible answers for a Question (for Multiple Choice questions) */
+    options: string[];
+    /** The actually correct answer expected */
+    expected: string;
+    /** How many points this question is worth, roughly indicating its importance and difficulty */
+    points: number;
+    /** Whether or not this question is ready to display to students */
+    published: boolean;
+}
diff --git a/src/objects.test.ts b/src/objects.test.ts
index bcff7ab176..a9c76a334e 100644
--- a/src/objects.test.ts
+++ b/src/objects.test.ts
@@ -1,7 +1,7 @@
+import { Question } from "./interfaces/question";
 import {
     makeBlankQuestion,
     isCorrect,
-    Question,
     isValid,
     toShortForm,
     toMarkdown,
diff --git a/src/objects.ts b/src/objects.ts
index d03dd473e3..3fd2072e5e 100644
--- a/src/objects.ts
+++ b/src/objects.ts
@@ -1,24 +1,4 @@
-/** QuestionType influences how a question is asked and what kinds of answers are possible */
-export type QuestionType = "multiple_choice_question" | "short_answer_question";
-
-export interface Question {
-    /** A unique identifier for the question */
-    id: number;
-    /** The human-friendly title of the question */
-    name: string;
-    /** The instructions and content of the Question */
-    body: string;
-    /** The kind of Question; influences how the user answers and what options are displayed */
-    type: QuestionType;
-    /** The possible answers for a Question (for Multiple Choice questions) */
-    options: string[];
-    /** The actually correct answer expected */
-    expected: string;
-    /** How many points this question is worth, roughly indicating its importance and difficulty */
-    points: number;
-    /** Whether or not this question is ready to display to students */
-    published: boolean;
-}
+import { Question, QuestionType } from "./interfaces/question";
 
 /**
  * Create a new blank question with the given `id`, `name`, and `type. The `body` and

From 9b9adb6f2ccbd1113a09cb8e13186d6d4f829928 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sat, 24 Aug 2024 13:27:44 -0400
Subject: [PATCH 25/46] Fix formatting

---
 src/objects.test.ts | 70 ++++++++++++++++++++++++---------------------
 1 file changed, 37 insertions(+), 33 deletions(-)

diff --git a/src/objects.test.ts b/src/objects.test.ts
index a9c76a334e..4d3117405d 100644
--- a/src/objects.test.ts
+++ b/src/objects.test.ts
@@ -9,7 +9,7 @@ import {
     renameQuestion,
     publishQuestion,
     addOption,
-    mergeQuestion
+    mergeQuestion,
 } from "./objects";
 import testQuestionData from "./data/questions.json";
 import backupQuestionData from "./data/questions.json";
@@ -25,7 +25,7 @@ const { BLANK_QUESTIONS, SIMPLE_QUESTIONS }: Record<string, Question[]> =
 // We have backup versions of the data to make sure all changes are immutable
 const {
     BLANK_QUESTIONS: BACKUP_BLANK_QUESTIONS,
-    SIMPLE_QUESTIONS: BACKUP_SIMPLE_QUESTIONS
+    SIMPLE_QUESTIONS: BACKUP_SIMPLE_QUESTIONS,
 }: Record<string, Question[]> = backupQuestionData as Record<
     string,
     Question[]
@@ -38,7 +38,7 @@ const [
     BACKUP_ADDITION_QUESTION,
     BACKUP_LETTER_QUESTION,
     BACKUP_COLOR_QUESTION,
-    BACKUP_SHAPE_QUESTION
+    BACKUP_SHAPE_QUESTION,
 ] = BACKUP_SIMPLE_QUESTIONS;
 
 ////////////////////////////////////////////
@@ -48,21 +48,25 @@ describe("Testing the object functions", () => {
     //////////////////////////////////
     // makeBlankQuestion
 
-    test("Testing the makeBlankQuestion function", () => {
+    test("(3 pts) Testing the makeBlankQuestion function", () => {
         expect(
-            makeBlankQuestion(1, "Question 1", "multiple_choice_question")
+            makeBlankQuestion(1, "Question 1", "multiple_choice_question"),
         ).toEqual(BLANK_QUESTIONS[0]);
         expect(
-            makeBlankQuestion(47, "My New Question", "multiple_choice_question")
+            makeBlankQuestion(
+                47,
+                "My New Question",
+                "multiple_choice_question",
+            ),
         ).toEqual(BLANK_QUESTIONS[1]);
         expect(
-            makeBlankQuestion(2, "Question 2", "short_answer_question")
+            makeBlankQuestion(2, "Question 2", "short_answer_question"),
         ).toEqual(BLANK_QUESTIONS[2]);
     });
 
     ///////////////////////////////////
     // isCorrect
-    test("Testing the isCorrect function", () => {
+    test("(3 pts) Testing the isCorrect function", () => {
         expect(isCorrect(ADDITION_QUESTION, "4")).toEqual(true);
         expect(isCorrect(ADDITION_QUESTION, "2")).toEqual(false);
         expect(isCorrect(ADDITION_QUESTION, " 4\n")).toEqual(true);
@@ -81,7 +85,7 @@ describe("Testing the object functions", () => {
 
     ///////////////////////////////////
     // isValid
-    test("Testing the isValid function", () => {
+    test("(3 pts) Testing the isValid function", () => {
         expect(isValid(ADDITION_QUESTION, "4")).toEqual(true);
         expect(isValid(ADDITION_QUESTION, "2")).toEqual(true);
         expect(isValid(ADDITION_QUESTION, " 4\n")).toEqual(true);
@@ -104,7 +108,7 @@ describe("Testing the object functions", () => {
 
     ///////////////////////////////////
     // toShortForm
-    test("Testing the toShortForm function", () => {
+    test("(3 pts) Testing the toShortForm function", () => {
         expect(toShortForm(ADDITION_QUESTION)).toEqual("1: Addition");
         expect(toShortForm(LETTER_QUESTION)).toEqual("2: Letters");
         expect(toShortForm(COLOR_QUESTION)).toEqual("5: Colors");
@@ -114,7 +118,7 @@ describe("Testing the object functions", () => {
 
     ///////////////////////////////////
     // toMarkdown
-    test("Testing the toMarkdown function", () => {
+    test("(3 pts) Testing the toMarkdown function", () => {
         expect(toMarkdown(ADDITION_QUESTION)).toEqual(`# Addition
 What is 2+2?`);
         expect(toMarkdown(LETTER_QUESTION)).toEqual(`# Letters
@@ -141,9 +145,9 @@ What shape can you make with one line?
 
     ///////////////////////////////////
     // renameQuestion
-    test("Testing the renameQuestion function", () => {
+    test("(3 pts) Testing the renameQuestion function", () => {
         expect(
-            renameQuestion(ADDITION_QUESTION, "My Addition Question")
+            renameQuestion(ADDITION_QUESTION, "My Addition Question"),
         ).toEqual({
             id: 1,
             name: "My Addition Question",
@@ -152,10 +156,10 @@ What shape can you make with one line?
             options: [],
             expected: "4",
             points: 1,
-            published: true
+            published: true,
         });
         expect(
-            renameQuestion(SHAPE_QUESTION, "I COMPLETELY CHANGED THIS NAME")
+            renameQuestion(SHAPE_QUESTION, "I COMPLETELY CHANGED THIS NAME"),
         ).toEqual({
             id: 9,
             name: "I COMPLETELY CHANGED THIS NAME",
@@ -164,13 +168,13 @@ What shape can you make with one line?
             options: ["square", "triangle", "circle"],
             expected: "circle",
             points: 2,
-            published: false
+            published: false,
         });
     });
 
     ///////////////////////////////////
     // publishQuestion
-    test("Testing the publishQuestion function", () => {
+    test("(3 pts) Testing the publishQuestion function", () => {
         expect(publishQuestion(ADDITION_QUESTION)).toEqual({
             id: 1,
             name: "Addition",
@@ -179,7 +183,7 @@ What shape can you make with one line?
             options: [],
             expected: "4",
             points: 1,
-            published: false
+            published: false,
         });
         expect(publishQuestion(LETTER_QUESTION)).toEqual({
             id: 2,
@@ -189,7 +193,7 @@ What shape can you make with one line?
             options: [],
             expected: "Z",
             points: 1,
-            published: true
+            published: true,
         });
         expect(publishQuestion(publishQuestion(ADDITION_QUESTION))).toEqual({
             id: 1,
@@ -199,13 +203,13 @@ What shape can you make with one line?
             options: [],
             expected: "4",
             points: 1,
-            published: true
+            published: true,
         });
     });
 
     ///////////////////////////////////
     // duplicateQuestion
-    test("Testing the duplicateQuestion function", () => {
+    test("(3 pts) Testing the duplicateQuestion function", () => {
         expect(duplicateQuestion(9, ADDITION_QUESTION)).toEqual({
             id: 9,
             name: "Copy of Addition",
@@ -214,7 +218,7 @@ What shape can you make with one line?
             options: [],
             expected: "4",
             points: 1,
-            published: false
+            published: false,
         });
         expect(duplicateQuestion(55, LETTER_QUESTION)).toEqual({
             id: 55,
@@ -224,13 +228,13 @@ What shape can you make with one line?
             options: [],
             expected: "Z",
             points: 1,
-            published: false
+            published: false,
         });
     });
 
     ///////////////////////////////////
     // addOption
-    test("Testing the addOption function", () => {
+    test("(3 pts) Testing the addOption function", () => {
         expect(addOption(SHAPE_QUESTION, "heptagon")).toEqual({
             id: 9,
             name: "Shapes",
@@ -239,7 +243,7 @@ What shape can you make with one line?
             options: ["square", "triangle", "circle", "heptagon"],
             expected: "circle",
             points: 2,
-            published: false
+            published: false,
         });
         expect(addOption(COLOR_QUESTION, "squiggles")).toEqual({
             id: 5,
@@ -249,20 +253,20 @@ What shape can you make with one line?
             options: ["red", "apple", "firetruck", "squiggles"],
             expected: "red",
             points: 1,
-            published: true
+            published: true,
         });
     });
 
     ///////////////////////////////////
     // mergeQuestion
-    test("Testing the mergeQuestion function", () => {
+    test("(3 pts) Testing the mergeQuestion function", () => {
         expect(
             mergeQuestion(
                 192,
                 "More Points Addition",
                 ADDITION_QUESTION,
-                SHAPE_QUESTION
-            )
+                SHAPE_QUESTION,
+            ),
         ).toEqual({
             id: 192,
             name: "More Points Addition",
@@ -271,7 +275,7 @@ What shape can you make with one line?
             options: [],
             expected: "4",
             points: 2,
-            published: false
+            published: false,
         });
 
         expect(
@@ -279,8 +283,8 @@ What shape can you make with one line?
                 99,
                 "Less Points Shape",
                 SHAPE_QUESTION,
-                ADDITION_QUESTION
-            )
+                ADDITION_QUESTION,
+            ),
         ).toEqual({
             id: 99,
             name: "Less Points Shape",
@@ -289,7 +293,7 @@ What shape can you make with one line?
             options: ["square", "triangle", "circle"],
             expected: "circle",
             points: 1,
-            published: false
+            published: false,
         });
     });
 });

From 3660252c2f3f53f262fadb91e8d14d0eeffa6cd2 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Wed, 2 Feb 2022 13:12:40 -0500
Subject: [PATCH 26/46] First stab at questions

---
 public/tasks/task-objects.md |   5 +
 src/data/questions.json      |  79 ++++++++++
 src/objects.test.ts          | 295 +++++++++++++++++++++++++++++++++++
 src/objects.ts               | 141 +++++++++++++++++
 4 files changed, 520 insertions(+)
 create mode 100644 public/tasks/task-objects.md
 create mode 100644 src/data/questions.json
 create mode 100644 src/objects.test.ts
 create mode 100644 src/objects.ts

diff --git a/public/tasks/task-objects.md b/public/tasks/task-objects.md
new file mode 100644
index 0000000000..480889da0d
--- /dev/null
+++ b/public/tasks/task-objects.md
@@ -0,0 +1,5 @@
+# Task - Objects
+
+Version: 0.0.1
+
+Implement functions that work with objects immutably.
diff --git a/src/data/questions.json b/src/data/questions.json
new file mode 100644
index 0000000000..3b19537526
--- /dev/null
+++ b/src/data/questions.json
@@ -0,0 +1,79 @@
+{
+    "BLANK_QUESTIONS": [
+        {
+            "id": 1,
+            "name": "Question 1",
+            "body": "",
+            "type": "multiple_choice_question",
+            "options": [],
+            "expected": "",
+            "points": 1,
+            "published": false
+        },
+        {
+            "id": 47,
+            "name": "My New Question",
+            "body": "",
+            "type": "multiple_choice_question",
+            "options": [],
+            "expected": "",
+            "points": 1,
+            "published": false
+        },
+        {
+            "id": 2,
+            "name": "Question 2",
+            "body": "",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "",
+            "points": 1,
+            "published": false
+        }
+    ],
+    "SIMPLE_QUESTIONS": [
+        {
+            "id": 1,
+            "name": "Addition",
+            "body": "What is 2+2?",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "4",
+            "points": 1,
+            "published": true
+        },
+        {
+            "id": 2,
+            "name": "Letters",
+            "body": "What is the last letter of the English alphabet?",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "Z",
+            "points": 1,
+            "published": false
+        },
+        {
+            "id": 5,
+            "name": "Colors",
+            "body": "Which of these is a color?",
+            "type": "multiple_choice_question",
+            "options": ["red", "apple", "firetruck"],
+            "expected": "red",
+            "points": 1,
+            "published": true
+        },
+        {
+            "id": 9,
+            "name": "Shapes",
+            "body": "What shape can you make with one line?",
+            "type": "multiple_choice_question",
+            "options": ["square", "triangle", "circle"],
+            "expected": "circle",
+            "points": 2,
+            "published": false
+        }
+    ],
+    "SIMPLE_QUESTIONS_2": [],
+    "EMPTY_QUESTIONS": [],
+    "TRIVIA_QUESTIONS": []
+}
diff --git a/src/objects.test.ts b/src/objects.test.ts
new file mode 100644
index 0000000000..bcff7ab176
--- /dev/null
+++ b/src/objects.test.ts
@@ -0,0 +1,295 @@
+import {
+    makeBlankQuestion,
+    isCorrect,
+    Question,
+    isValid,
+    toShortForm,
+    toMarkdown,
+    duplicateQuestion,
+    renameQuestion,
+    publishQuestion,
+    addOption,
+    mergeQuestion
+} from "./objects";
+import testQuestionData from "./data/questions.json";
+import backupQuestionData from "./data/questions.json";
+
+////////////////////////////////////////////
+// Setting up the test data
+
+const { BLANK_QUESTIONS, SIMPLE_QUESTIONS }: Record<string, Question[]> =
+    // Typecast the test data that we imported to be a record matching
+    //  strings to the question list
+    testQuestionData as Record<string, Question[]>;
+
+// We have backup versions of the data to make sure all changes are immutable
+const {
+    BLANK_QUESTIONS: BACKUP_BLANK_QUESTIONS,
+    SIMPLE_QUESTIONS: BACKUP_SIMPLE_QUESTIONS
+}: Record<string, Question[]> = backupQuestionData as Record<
+    string,
+    Question[]
+>;
+
+// Unpack the list of simple questions into convenient constants
+const [ADDITION_QUESTION, LETTER_QUESTION, COLOR_QUESTION, SHAPE_QUESTION] =
+    SIMPLE_QUESTIONS;
+const [
+    BACKUP_ADDITION_QUESTION,
+    BACKUP_LETTER_QUESTION,
+    BACKUP_COLOR_QUESTION,
+    BACKUP_SHAPE_QUESTION
+] = BACKUP_SIMPLE_QUESTIONS;
+
+////////////////////////////////////////////
+// Actual tests
+
+describe("Testing the object functions", () => {
+    //////////////////////////////////
+    // makeBlankQuestion
+
+    test("Testing the makeBlankQuestion function", () => {
+        expect(
+            makeBlankQuestion(1, "Question 1", "multiple_choice_question")
+        ).toEqual(BLANK_QUESTIONS[0]);
+        expect(
+            makeBlankQuestion(47, "My New Question", "multiple_choice_question")
+        ).toEqual(BLANK_QUESTIONS[1]);
+        expect(
+            makeBlankQuestion(2, "Question 2", "short_answer_question")
+        ).toEqual(BLANK_QUESTIONS[2]);
+    });
+
+    ///////////////////////////////////
+    // isCorrect
+    test("Testing the isCorrect function", () => {
+        expect(isCorrect(ADDITION_QUESTION, "4")).toEqual(true);
+        expect(isCorrect(ADDITION_QUESTION, "2")).toEqual(false);
+        expect(isCorrect(ADDITION_QUESTION, " 4\n")).toEqual(true);
+        expect(isCorrect(LETTER_QUESTION, "Z")).toEqual(true);
+        expect(isCorrect(LETTER_QUESTION, "z")).toEqual(true);
+        expect(isCorrect(LETTER_QUESTION, "4")).toEqual(false);
+        expect(isCorrect(LETTER_QUESTION, "0")).toEqual(false);
+        expect(isCorrect(LETTER_QUESTION, "zed")).toEqual(false);
+        expect(isCorrect(COLOR_QUESTION, "red")).toEqual(true);
+        expect(isCorrect(COLOR_QUESTION, "apple")).toEqual(false);
+        expect(isCorrect(COLOR_QUESTION, "firetruck")).toEqual(false);
+        expect(isCorrect(SHAPE_QUESTION, "square")).toEqual(false);
+        expect(isCorrect(SHAPE_QUESTION, "triangle")).toEqual(false);
+        expect(isCorrect(SHAPE_QUESTION, "circle")).toEqual(true);
+    });
+
+    ///////////////////////////////////
+    // isValid
+    test("Testing the isValid function", () => {
+        expect(isValid(ADDITION_QUESTION, "4")).toEqual(true);
+        expect(isValid(ADDITION_QUESTION, "2")).toEqual(true);
+        expect(isValid(ADDITION_QUESTION, " 4\n")).toEqual(true);
+        expect(isValid(LETTER_QUESTION, "Z")).toEqual(true);
+        expect(isValid(LETTER_QUESTION, "z")).toEqual(true);
+        expect(isValid(LETTER_QUESTION, "4")).toEqual(true);
+        expect(isValid(LETTER_QUESTION, "0")).toEqual(true);
+        expect(isValid(LETTER_QUESTION, "zed")).toEqual(true);
+        expect(isValid(COLOR_QUESTION, "red")).toEqual(true);
+        expect(isValid(COLOR_QUESTION, "apple")).toEqual(true);
+        expect(isValid(COLOR_QUESTION, "firetruck")).toEqual(true);
+        expect(isValid(COLOR_QUESTION, "RED")).toEqual(false);
+        expect(isValid(COLOR_QUESTION, "orange")).toEqual(false);
+        expect(isValid(SHAPE_QUESTION, "square")).toEqual(true);
+        expect(isValid(SHAPE_QUESTION, "triangle")).toEqual(true);
+        expect(isValid(SHAPE_QUESTION, "circle")).toEqual(true);
+        expect(isValid(SHAPE_QUESTION, "circle ")).toEqual(false);
+        expect(isValid(SHAPE_QUESTION, "rhombus")).toEqual(false);
+    });
+
+    ///////////////////////////////////
+    // toShortForm
+    test("Testing the toShortForm function", () => {
+        expect(toShortForm(ADDITION_QUESTION)).toEqual("1: Addition");
+        expect(toShortForm(LETTER_QUESTION)).toEqual("2: Letters");
+        expect(toShortForm(COLOR_QUESTION)).toEqual("5: Colors");
+        expect(toShortForm(SHAPE_QUESTION)).toEqual("9: Shapes");
+        expect(toShortForm(BLANK_QUESTIONS[1])).toEqual("47: My New Que");
+    });
+
+    ///////////////////////////////////
+    // toMarkdown
+    test("Testing the toMarkdown function", () => {
+        expect(toMarkdown(ADDITION_QUESTION)).toEqual(`# Addition
+What is 2+2?`);
+        expect(toMarkdown(LETTER_QUESTION)).toEqual(`# Letters
+What is the last letter of the English alphabet?`);
+        expect(toMarkdown(COLOR_QUESTION)).toEqual(`# Colors
+Which of these is a color?
+- red
+- apple
+- firetruck`);
+        expect(toMarkdown(SHAPE_QUESTION)).toEqual(`# Shapes
+What shape can you make with one line?
+- square
+- triangle
+- circle`);
+    });
+
+    afterEach(() => {
+        expect(ADDITION_QUESTION).toEqual(BACKUP_ADDITION_QUESTION);
+        expect(LETTER_QUESTION).toEqual(BACKUP_LETTER_QUESTION);
+        expect(SHAPE_QUESTION).toEqual(BACKUP_SHAPE_QUESTION);
+        expect(COLOR_QUESTION).toEqual(BACKUP_COLOR_QUESTION);
+        expect(BLANK_QUESTIONS).toEqual(BACKUP_BLANK_QUESTIONS);
+    });
+
+    ///////////////////////////////////
+    // renameQuestion
+    test("Testing the renameQuestion function", () => {
+        expect(
+            renameQuestion(ADDITION_QUESTION, "My Addition Question")
+        ).toEqual({
+            id: 1,
+            name: "My Addition Question",
+            body: "What is 2+2?",
+            type: "short_answer_question",
+            options: [],
+            expected: "4",
+            points: 1,
+            published: true
+        });
+        expect(
+            renameQuestion(SHAPE_QUESTION, "I COMPLETELY CHANGED THIS NAME")
+        ).toEqual({
+            id: 9,
+            name: "I COMPLETELY CHANGED THIS NAME",
+            body: "What shape can you make with one line?",
+            type: "multiple_choice_question",
+            options: ["square", "triangle", "circle"],
+            expected: "circle",
+            points: 2,
+            published: false
+        });
+    });
+
+    ///////////////////////////////////
+    // publishQuestion
+    test("Testing the publishQuestion function", () => {
+        expect(publishQuestion(ADDITION_QUESTION)).toEqual({
+            id: 1,
+            name: "Addition",
+            body: "What is 2+2?",
+            type: "short_answer_question",
+            options: [],
+            expected: "4",
+            points: 1,
+            published: false
+        });
+        expect(publishQuestion(LETTER_QUESTION)).toEqual({
+            id: 2,
+            name: "Letters",
+            body: "What is the last letter of the English alphabet?",
+            type: "short_answer_question",
+            options: [],
+            expected: "Z",
+            points: 1,
+            published: true
+        });
+        expect(publishQuestion(publishQuestion(ADDITION_QUESTION))).toEqual({
+            id: 1,
+            name: "Addition",
+            body: "What is 2+2?",
+            type: "short_answer_question",
+            options: [],
+            expected: "4",
+            points: 1,
+            published: true
+        });
+    });
+
+    ///////////////////////////////////
+    // duplicateQuestion
+    test("Testing the duplicateQuestion function", () => {
+        expect(duplicateQuestion(9, ADDITION_QUESTION)).toEqual({
+            id: 9,
+            name: "Copy of Addition",
+            body: "What is 2+2?",
+            type: "short_answer_question",
+            options: [],
+            expected: "4",
+            points: 1,
+            published: false
+        });
+        expect(duplicateQuestion(55, LETTER_QUESTION)).toEqual({
+            id: 55,
+            name: "Copy of Letters",
+            body: "What is the last letter of the English alphabet?",
+            type: "short_answer_question",
+            options: [],
+            expected: "Z",
+            points: 1,
+            published: false
+        });
+    });
+
+    ///////////////////////////////////
+    // addOption
+    test("Testing the addOption function", () => {
+        expect(addOption(SHAPE_QUESTION, "heptagon")).toEqual({
+            id: 9,
+            name: "Shapes",
+            body: "What shape can you make with one line?",
+            type: "multiple_choice_question",
+            options: ["square", "triangle", "circle", "heptagon"],
+            expected: "circle",
+            points: 2,
+            published: false
+        });
+        expect(addOption(COLOR_QUESTION, "squiggles")).toEqual({
+            id: 5,
+            name: "Colors",
+            body: "Which of these is a color?",
+            type: "multiple_choice_question",
+            options: ["red", "apple", "firetruck", "squiggles"],
+            expected: "red",
+            points: 1,
+            published: true
+        });
+    });
+
+    ///////////////////////////////////
+    // mergeQuestion
+    test("Testing the mergeQuestion function", () => {
+        expect(
+            mergeQuestion(
+                192,
+                "More Points Addition",
+                ADDITION_QUESTION,
+                SHAPE_QUESTION
+            )
+        ).toEqual({
+            id: 192,
+            name: "More Points Addition",
+            body: "What is 2+2?",
+            type: "short_answer_question",
+            options: [],
+            expected: "4",
+            points: 2,
+            published: false
+        });
+
+        expect(
+            mergeQuestion(
+                99,
+                "Less Points Shape",
+                SHAPE_QUESTION,
+                ADDITION_QUESTION
+            )
+        ).toEqual({
+            id: 99,
+            name: "Less Points Shape",
+            body: "What shape can you make with one line?",
+            type: "multiple_choice_question",
+            options: ["square", "triangle", "circle"],
+            expected: "circle",
+            points: 1,
+            published: false
+        });
+    });
+});
diff --git a/src/objects.ts b/src/objects.ts
new file mode 100644
index 0000000000..d03dd473e3
--- /dev/null
+++ b/src/objects.ts
@@ -0,0 +1,141 @@
+/** QuestionType influences how a question is asked and what kinds of answers are possible */
+export type QuestionType = "multiple_choice_question" | "short_answer_question";
+
+export interface Question {
+    /** A unique identifier for the question */
+    id: number;
+    /** The human-friendly title of the question */
+    name: string;
+    /** The instructions and content of the Question */
+    body: string;
+    /** The kind of Question; influences how the user answers and what options are displayed */
+    type: QuestionType;
+    /** The possible answers for a Question (for Multiple Choice questions) */
+    options: string[];
+    /** The actually correct answer expected */
+    expected: string;
+    /** How many points this question is worth, roughly indicating its importance and difficulty */
+    points: number;
+    /** Whether or not this question is ready to display to students */
+    published: boolean;
+}
+
+/**
+ * Create a new blank question with the given `id`, `name`, and `type. The `body` and
+ * `expected` should be empty strings, the `options` should be an empty list, the `points`
+ * should default to 1, and `published` should default to false.
+ */
+export function makeBlankQuestion(
+    id: number,
+    name: string,
+    type: QuestionType
+): Question {
+    return {};
+}
+
+/**
+ * Consumes a question and a potential `answer`, and returns whether or not
+ * the `answer` is correct. You should check that the `answer` is equal to
+ * the `expected`, ignoring capitalization and trimming any whitespace.
+ *
+ * HINT: Look up the `trim` and `toLowerCase` functions.
+ */
+export function isCorrect(question: Question, answer: string): boolean {
+    return false;
+}
+
+/**
+ * Consumes a question and a potential `answer`, and returns whether or not
+ * the `answer` is valid (but not necessarily correct). For a `short_answer_question`,
+ * any answer is valid. But for a `multiple_choice_question`, the `answer` must
+ * be exactly one of the options.
+ */
+export function isValid(question: Question, answer: string): boolean {
+    return false;
+}
+
+/**
+ * Consumes a question and produces a string representation combining the
+ * `id` and first 10 characters of the `name`. The two strings should be
+ * separated by ": ". So for example, the question with id 9 and the
+ * name "My First Question" would become "9: My First Q".
+ */
+export function toShortForm(question: Question): string {
+    return "";
+}
+
+/**
+ * Consumes a question and returns a formatted string representation as follows:
+ *  - The first line should be a hash sign, a space, and then the `name`
+ *  - The second line should be the `body`
+ *  - If the question is a `multiple_choice_question`, then the following lines
+ *      need to show each option on its line, preceded by a dash and space.
+ *
+ * The example below might help, but don't include the border!
+ * ----------Example-------------
+ * |# Name                      |
+ * |The body goes here!         |
+ * |- Option 1                  |
+ * |- Option 2                  |
+ * |- Option 3                  |
+ * ------------------------------
+ * Check the unit tests for more examples of what this looks like!
+ */
+export function toMarkdown(question: Question): string {
+    return "";
+}
+
+/**
+ * Return a new version of the given question, except the name should now be
+ * `newName`.
+ */
+export function renameQuestion(question: Question, newName: string): Question {
+    return question;
+}
+
+/**
+ * Return a new version of the given question, except the `published` field
+ * should be inverted. If the question was not published, now it should be
+ * published; if it was published, now it should be not published.
+ */
+export function publishQuestion(question: Question): Question {
+    return question;
+}
+
+/**
+ * Create a new question based on the old question, copying over its `body`, `type`,
+ * `options`, `expected`, and `points` without changes. The `name` should be copied
+ * over as "Copy of ORIGINAL NAME" (e.g., so "Question 1" would become "Copy of Question 1").
+ * The `published` field should be reset to false.
+ */
+export function duplicateQuestion(id: number, oldQuestion: Question): Question {
+    return oldQuestion;
+}
+
+/**
+ * Return a new version of the given question, with the `newOption` added to
+ * the list of existing `options`. Remember that the new Question MUST have
+ * its own separate copy of the `options` list, rather than the same reference
+ * to the original question's list!
+ * Check out the subsection about "Nested Fields" for more information.
+ */
+export function addOption(question: Question, newOption: string): Question {
+    return question;
+}
+
+/**
+ * Consumes an id, name, and two questions, and produces a new question.
+ * The new question will use the `body`, `type`, `options`, and `expected` of the
+ * `contentQuestion`. The second question will provide the `points`.
+ * The `published` status should be set to false.
+ * Notice that the second Question is provided as just an object with a `points`
+ * field; but the function call would be the same as if it were a `Question` type!
+ */
+export function mergeQuestion(
+    id: number,
+    name: string,
+    contentQuestion: Question,
+    { points }: { points: number }
+): Question {
+    return contentQuestion;
+}

From 09d3d4f104a2cacab2641271c5c6cab55424efd1 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sun, 6 Feb 2022 18:33:46 -0500
Subject: [PATCH 27/46] Move Question interface to separate file

---
 src/interfaces/question.ts | 21 +++++++++++++++++++++
 src/objects.test.ts        |  2 +-
 src/objects.ts             | 22 +---------------------
 3 files changed, 23 insertions(+), 22 deletions(-)
 create mode 100644 src/interfaces/question.ts

diff --git a/src/interfaces/question.ts b/src/interfaces/question.ts
new file mode 100644
index 0000000000..a39431565e
--- /dev/null
+++ b/src/interfaces/question.ts
@@ -0,0 +1,21 @@
+/** QuestionType influences how a question is asked and what kinds of answers are possible */
+export type QuestionType = "multiple_choice_question" | "short_answer_question";
+
+export interface Question {
+    /** A unique identifier for the question */
+    id: number;
+    /** The human-friendly title of the question */
+    name: string;
+    /** The instructions and content of the Question */
+    body: string;
+    /** The kind of Question; influences how the user answers and what options are displayed */
+    type: QuestionType;
+    /** The possible answers for a Question (for Multiple Choice questions) */
+    options: string[];
+    /** The actually correct answer expected */
+    expected: string;
+    /** How many points this question is worth, roughly indicating its importance and difficulty */
+    points: number;
+    /** Whether or not this question is ready to display to students */
+    published: boolean;
+}
diff --git a/src/objects.test.ts b/src/objects.test.ts
index bcff7ab176..a9c76a334e 100644
--- a/src/objects.test.ts
+++ b/src/objects.test.ts
@@ -1,7 +1,7 @@
+import { Question } from "./interfaces/question";
 import {
     makeBlankQuestion,
     isCorrect,
-    Question,
     isValid,
     toShortForm,
     toMarkdown,
diff --git a/src/objects.ts b/src/objects.ts
index d03dd473e3..3fd2072e5e 100644
--- a/src/objects.ts
+++ b/src/objects.ts
@@ -1,24 +1,4 @@
-/** QuestionType influences how a question is asked and what kinds of answers are possible */
-export type QuestionType = "multiple_choice_question" | "short_answer_question";
-
-export interface Question {
-    /** A unique identifier for the question */
-    id: number;
-    /** The human-friendly title of the question */
-    name: string;
-    /** The instructions and content of the Question */
-    body: string;
-    /** The kind of Question; influences how the user answers and what options are displayed */
-    type: QuestionType;
-    /** The possible answers for a Question (for Multiple Choice questions) */
-    options: string[];
-    /** The actually correct answer expected */
-    expected: string;
-    /** How many points this question is worth, roughly indicating its importance and difficulty */
-    points: number;
-    /** Whether or not this question is ready to display to students */
-    published: boolean;
-}
+import { Question, QuestionType } from "./interfaces/question";
 
 /**
  * Create a new blank question with the given `id`, `name`, and `type. The `body` and

From 9a2402444e847b2c05ce0c9a6887534a249d7c46 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Tue, 8 Feb 2022 00:36:21 -0500
Subject: [PATCH 28/46] Create answer interface

---
 src/interfaces/answer.ts | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 src/interfaces/answer.ts

diff --git a/src/interfaces/answer.ts b/src/interfaces/answer.ts
new file mode 100644
index 0000000000..743ee8dff9
--- /dev/null
+++ b/src/interfaces/answer.ts
@@ -0,0 +1,13 @@
+/***
+ * A representation of a students' answer in a quizzing game
+ */
+export interface Answer {
+    /** The ID of the question being answered. */
+    questionId: number;
+    /** The text that the student entered for their answer. */
+    text: string;
+    /** Whether or not the student has submitted this answer. */
+    submitted: boolean;
+    /** Whether or not the students' answer matched the expected. */
+    correct: boolean;
+}

From 879fe177e356794eedf9f893fe0e865e49f36eb7 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Tue, 8 Feb 2022 00:36:37 -0500
Subject: [PATCH 29/46] First stab at nested tasks

---
 src/nested.test.ts |  57 +++++++++++++++
 src/nested.ts      | 178 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 235 insertions(+)
 create mode 100644 src/nested.test.ts
 create mode 100644 src/nested.ts

diff --git a/src/nested.test.ts b/src/nested.test.ts
new file mode 100644
index 0000000000..1e3ff24b5c
--- /dev/null
+++ b/src/nested.test.ts
@@ -0,0 +1,57 @@
+import { Question } from "./interfaces/question";
+import { getPublishedQuestions } from "./nested";
+import testQuestionData from "./data/questions.json";
+import backupQuestionData from "./data/questions.json";
+
+const { BLANK_QUESTIONS, SIMPLE_QUESTIONS }: Record<string, Question[]> =
+    // Typecast the test data that we imported to be a record matching
+    //  strings to the question list
+    testQuestionData as Record<string, Question[]>;
+
+// We have backup versions of the data to make sure all changes are immutable
+const {
+    BLANK_QUESTIONS: BACKUP_BLANK_QUESTIONS,
+    SIMPLE_QUESTIONS: BACKUP_SIMPLE_QUESTIONS
+}: Record<string, Question[]> = backupQuestionData as Record<
+    string,
+    Question[]
+>;
+
+////////////////////////////////////////////
+// Actual tests
+
+describe("Testing the Question[] functions", () => {
+    //////////////////////////////////
+    // getPublishedQuestions
+
+    test("Testing the getPublishedQuestions function", () => {
+        expect(getPublishedQuestions(BLANK_QUESTIONS)).toEqual([]);
+        expect(getPublishedQuestions(SIMPLE_QUESTIONS)).toEqual([
+            {
+                id: 1,
+                name: "Addition",
+                body: "What is 2+2?",
+                type: "short_answer_question",
+                options: [],
+                expected: "4",
+                points: 1,
+                published: true
+            },
+            {
+                id: 5,
+                name: "Colors",
+                body: "Which of these is a color?",
+                type: "multiple_choice_question",
+                options: ["red", "apple", "firetruck"],
+                expected: "red",
+                points: 1,
+                published: true
+            }
+        ]);
+    });
+
+    afterEach(() => {
+        expect(BLANK_QUESTIONS).toEqual(BACKUP_BLANK_QUESTIONS);
+        expect(SIMPLE_QUESTIONS).toEqual(BACKUP_SIMPLE_QUESTIONS);
+    });
+});
diff --git a/src/nested.ts b/src/nested.ts
new file mode 100644
index 0000000000..b9fb13f3cf
--- /dev/null
+++ b/src/nested.ts
@@ -0,0 +1,178 @@
+import { Answer } from "./interfaces/answer";
+import { Question, QuestionType } from "./interfaces/question";
+
+/**
+ * Consumes an array of questions and returns a new array with only the questions
+ * that are `published`.
+ */
+export function getPublishedQuestions(questions: Question[]): Question[] {
+    return [];
+}
+
+/**
+ * Consumes an array of questions and returns a new array of only the questions that are
+ * considered "non-empty". An empty question has an empty string for its `body` and
+ * `expected`, and an empty array for its `options`.
+ */
+export function getNonEmptyQuestions(questions: Question[]): Question[] {
+    return [];
+}
+
+/***
+ * Consumes an array of questions and returns the question with the given `id`. If the
+ * question is not found, return `null` instead.
+ */
+export function findQuestion(
+    questions: Question[],
+    id: number
+): Question | null {
+    return null;
+}
+
+/**
+ * Consumes an array of questions and returns a new array that does not contain the question
+ * with the given `id`.
+ */
+export function removeQuestion(questions: Question[], id: number): Question[] {
+    return [];
+}
+
+/***
+ * Consumes an array of questions and returns a new array containing just the names of the
+ * questions, as an array.
+ */
+export function getNames(questions: Question[]): string[] {
+    return [];
+}
+
+/***
+ * Consumes an array of questions and returns the sum total of all their points added together.
+ */
+export function sumPoints(questions: Question[]): number {
+    return 0;
+}
+
+/***
+ * Consumes an array of questions and returns the sum total of the PUBLISHED questions.
+ */
+export function sumPublishedPoints(questions: Question[]): number {
+    return 0;
+}
+
+/***
+ * Consumes an array of questions, and produces a Comma-Separated Value (CSV) string representation.
+ * A CSV is a type of file frequently used to share tabular data; we will use a single string
+ * to represent the entire file. The first line of the file is the headers "id", "name", "options",
+ * "points", and "published". The following line contains the value for each question, separated by
+ * commas. For the `options` field, use the NUMBER of options.
+ *
+ * Here is an example of what this will look like (do not include the border).
+ *`
+id,name,options,points,published
+1,Addition,0,1,true
+2,Letters,0,1,false
+5,Colors,3,1,true
+9,Shapes,3,2,false
+` *
+ * Check the unit tests for more examples!
+ */
+export function toCSV(questions: Question[]): string {
+    return "";
+}
+
+/**
+ * Consumes an array of Questions and produces a corresponding array of
+ * Answers. Each Question gets its own Answer, copying over the `id` as the `questionId`,
+ * making the `text` an empty string, and using false for both `submitted` and `correct`.
+ */
+export function makeAnswers(questions: Question[]): Answer[] {
+    return [];
+}
+
+/***
+ * Consumes an array of Questions and produces a new array of questions, where
+ * each question is now published, regardless of its previous published status.
+ */
+export function publishAll(questions: Question[]): Question[] {
+    return [];
+}
+
+/***
+ * Consumes an array of Questions and produces whether or not all the questions
+ * are the same type. They can be any type, as long as they are all the SAME type.
+ */
+export function sameType(questions: Question[]): boolean {
+    return false;
+}
+
+/***
+ * Consumes an array of Questions and produces a new array of the same Questions,
+ * except that a blank question has been added onto the end. Reuse the `makeBlankQuestion`
+ * you defined in the `objects.ts` file.
+ */
+export function addNewQuestion(
+    questions: Question[],
+    id: number,
+    name: string,
+    type: QuestionType
+): Question[] {
+    return [];
+}
+
+/***
+ * Consumes an array of Questions and produces a new array of Questions, where all
+ * the Questions are the same EXCEPT for the one with the given `targetId`. That
+ * Question should be the same EXCEPT that its name should now be `newName`.
+ */
+export function renameQuestionById(
+    questions: Question[],
+    targetId: number,
+    newName: string
+): Question[] {
+    return [];
+}
+
+/***
+ * Consumes an array of Questions and produces a new array of Questions, where all
+ * the Questions are the same EXCEPT for the one with the given `targetId`. That
+ * Question should be the same EXCEPT that its `type` should now be the `newQuestionType`
+ * AND if the `newQuestionType` is no longer "multiple_choice_question" than the `options`
+ * must be set to an empty list.
+ */
+export function changeQuestionTypeById(
+    questions: Question[],
+    targetId: number,
+    newQuestionType: QuestionType
+): Question[] {
+    return [];
+}
+
+/**
+ * Consumes an array of Questions and produces a new array of Questions, where all
+ * the Questions are the same EXCEPT for the one with the given `targetId`. That
+ * Question should be the same EXCEPT that its `option` array should have a new element.
+ * If the `targetOptionIndex` is -1, the `newOption` should be added to the end of the list.
+ * Otherwise, it should *replace* the existing element at the `targetOptionIndex`.
+ */
+export function editOption(
+    questions: Question[],
+    targetId: number,
+    targetOptionIndex: number,
+    newOption: string
+) {
+    return [];
+}
+
+/***
+ * Consumes an array of questions, and produces a new array based on the original array.
+ * The only difference is that the question with id `targetId` should now be duplicated, with
+ * the duplicate inserted directly after the original question. Use the `duplicateQuestion`
+ * function you defined previously; the `newId` is the parameter to use for the duplicate's ID.
+ */
+export function duplicateQuestionInArray(
+    questions: Question[],
+    targetId: number,
+    newId: number
+): Question[] {
+    return [];
+}

From 4d29d2132a060f7f91420d71eea4e80ab72e7727 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Wed, 9 Feb 2022 13:20:35 -0500
Subject: [PATCH 30/46] Document Question interface

---
 src/interfaces/question.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/interfaces/question.ts b/src/interfaces/question.ts
index a39431565e..5def48f2f7 100644
--- a/src/interfaces/question.ts
+++ b/src/interfaces/question.ts
@@ -1,6 +1,7 @@
 /** QuestionType influences how a question is asked and what kinds of answers are possible */
 export type QuestionType = "multiple_choice_question" | "short_answer_question";
 
+/** A representation of a Question in a quizzing application */
 export interface Question {
     /** A unique identifier for the question */
     id: number;

From d71d9fcc94831dc1aea8d2aa847feeadeed6b9c4 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Wed, 9 Feb 2022 13:20:46 -0500
Subject: [PATCH 31/46] Expand questions test data

---
 src/data/questions.json | 147 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 144 insertions(+), 3 deletions(-)

diff --git a/src/data/questions.json b/src/data/questions.json
index 3b19537526..0411f30afe 100644
--- a/src/data/questions.json
+++ b/src/data/questions.json
@@ -73,7 +73,148 @@
             "published": false
         }
     ],
-    "SIMPLE_QUESTIONS_2": [],
-    "EMPTY_QUESTIONS": [],
-    "TRIVIA_QUESTIONS": []
+    "TRIVIA_QUESTIONS": [
+        {
+            "id": 1,
+            "name": "Mascot",
+            "body": "What is the name of the UD Mascot?",
+            "type": "multiple_choice_question",
+            "options": ["Bluey", "YoUDee", "Charles the Wonder Dog"],
+            "expected": "YoUDee",
+            "points": 7,
+            "published": false
+        },
+        {
+            "id": 2,
+            "name": "Motto",
+            "body": "What is the University of Delaware's motto?",
+            "type": "multiple_choice_question",
+            "options": [
+                "Knowledge is the light of the mind",
+                "Just U Do it",
+                "Nothing, what's the motto with you?"
+            ],
+            "expected": "Knowledge is the light of the mind",
+            "points": 3,
+            "published": false
+        },
+        {
+            "id": 3,
+            "name": "Goats",
+            "body": "How many goats are there usually on the Green?",
+            "type": "multiple_choice_question",
+            "options": [
+                "Zero, why would there be goats on the green?",
+                "18420",
+                "Two"
+            ],
+            "expected": "Two",
+            "points": 10,
+            "published": false
+        }
+    ],
+    "EMPTY_QUESTIONS": [
+        {
+            "id": 1,
+            "name": "Empty 1",
+            "body": "This question is not empty, right?",
+            "type": "multiple_choice_question",
+            "options": ["correct", "it is", "not"],
+            "expected": "correct",
+            "points": 5,
+            "published": true
+        },
+        {
+            "id": 2,
+            "name": "Empty 2",
+            "body": "",
+            "type": "multiple_choice_question",
+            "options": ["this", "one", "is", "not", "empty", "either"],
+            "expected": "one",
+            "points": 5,
+            "published": true
+        },
+        {
+            "id": 3,
+            "name": "Empty 3",
+            "body": "This questions is not empty either!",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "",
+            "points": 5,
+            "published": true
+        },
+        {
+            "id": 4,
+            "name": "Empty 4",
+            "body": "",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "Even this one is not empty",
+            "points": 5,
+            "published": true
+        },
+        {
+            "id": 5,
+            "name": "Empty 5 (Actual)",
+            "body": "",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "",
+            "points": 5,
+            "published": false
+        }
+    ],
+    "SIMPLE_QUESTIONS_2": [
+        {
+            "id": 478,
+            "name": "Students",
+            "body": "How many students are taking CISC275 this semester?",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "90",
+            "points": 53,
+            "published": true
+        },
+        {
+            "id": 1937,
+            "name": "Importance",
+            "body": "On a scale of 1 to 10, how important is this quiz for them?",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "10",
+            "points": 47,
+            "published": true
+        },
+        {
+            "id": 479,
+            "name": "Sentience",
+            "body": "Is it technically possible for this quiz to become sentient?",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "Yes",
+            "points": 40,
+            "published": true
+        },
+        {
+            "id": 777,
+            "name": "Danger",
+            "body": "If this quiz became sentient, would it pose a danger to others?",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "Yes",
+            "points": 60,
+            "published": true
+        },
+        {
+            "id": 1937,
+            "name": "Listening",
+            "body": "Is this quiz listening to us right now?",
+            "type": "short_answer_question",
+            "options": [],
+            "expected": "Yes",
+            "points": 100,
+            "published": true
+        }
+    ]
 }

From c955718b2a52fe88f0f3b27b00b8fcb74e8be0ca Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Wed, 9 Feb 2022 13:21:43 -0500
Subject: [PATCH 32/46] Add a little hint for a tough one

---
 src/nested.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/nested.ts b/src/nested.ts
index b9fb13f3cf..7934ec1741 100644
--- a/src/nested.ts
+++ b/src/nested.ts
@@ -153,6 +153,9 @@ export function changeQuestionTypeById(
  * Question should be the same EXCEPT that its `option` array should have a new element.
  * If the `targetOptionIndex` is -1, the `newOption` should be added to the end of the list.
  * Otherwise, it should *replace* the existing element at the `targetOptionIndex`.
+ *
+ * Remember, if a function starts getting too complicated, think about how a helper function
+ * can make it simpler! Break down complicated tasks into little pieces.
  */
 export function editOption(
     questions: Question[],

From c574699cc746d22d95223bfc85d2e0cb8d5843e8 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Wed, 9 Feb 2022 13:22:01 -0500
Subject: [PATCH 33/46] Nested tests (phew)

---
 src/nested.test.ts | 1187 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 1184 insertions(+), 3 deletions(-)

diff --git a/src/nested.test.ts b/src/nested.test.ts
index 1e3ff24b5c..3d2b75406d 100644
--- a/src/nested.test.ts
+++ b/src/nested.test.ts
@@ -1,9 +1,32 @@
 import { Question } from "./interfaces/question";
-import { getPublishedQuestions } from "./nested";
+import {
+    getPublishedQuestions,
+    getNonEmptyQuestions,
+    findQuestion,
+    removeQuestion,
+    getNames,
+    sumPoints,
+    sumPublishedPoints,
+    toCSV,
+    makeAnswers,
+    publishAll,
+    sameType,
+    addNewQuestion,
+    renameQuestionById,
+    changeQuestionTypeById,
+    editOption,
+    duplicateQuestionInArray
+} from "./nested";
 import testQuestionData from "./data/questions.json";
 import backupQuestionData from "./data/questions.json";
 
-const { BLANK_QUESTIONS, SIMPLE_QUESTIONS }: Record<string, Question[]> =
+const {
+    BLANK_QUESTIONS,
+    SIMPLE_QUESTIONS,
+    TRIVIA_QUESTIONS,
+    EMPTY_QUESTIONS,
+    SIMPLE_QUESTIONS_2
+}: Record<string, Question[]> =
     // Typecast the test data that we imported to be a record matching
     //  strings to the question list
     testQuestionData as Record<string, Question[]>;
@@ -11,12 +34,41 @@ const { BLANK_QUESTIONS, SIMPLE_QUESTIONS }: Record<string, Question[]> =
 // We have backup versions of the data to make sure all changes are immutable
 const {
     BLANK_QUESTIONS: BACKUP_BLANK_QUESTIONS,
-    SIMPLE_QUESTIONS: BACKUP_SIMPLE_QUESTIONS
+    SIMPLE_QUESTIONS: BACKUP_SIMPLE_QUESTIONS,
+    TRIVIA_QUESTIONS: BACKUP_TRIVIA_QUESTIONS,
+    EMPTY_QUESTIONS: BACKUP_EMPTY_QUESTIONS,
+    SIMPLE_QUESTIONS_2: BACKUP_SIMPLE_QUESTIONS_2
 }: Record<string, Question[]> = backupQuestionData as Record<
     string,
     Question[]
 >;
 
+const NEW_BLANK_QUESTION = {
+    id: 142,
+    name: "A new question",
+    body: "",
+    type: "short_answer_question",
+    options: [],
+    expected: "",
+    points: 1,
+    published: false
+};
+
+const NEW_TRIVIA_QUESTION = {
+    id: 449,
+    name: "Colors",
+    body: "",
+    type: "multiple_choice_question",
+    options: [],
+    expected: "",
+    /*body: "The official colors of UD are Blue and ...?",
+    type: "multiple_choice_question",
+    options: ["Black, like my soul", "Blue again, we're tricky.", "#FFD200"],
+    expected: "#FFD200",*/
+    points: 1,
+    published: false
+};
+
 ////////////////////////////////////////////
 // Actual tests
 
@@ -48,10 +100,1139 @@ describe("Testing the Question[] functions", () => {
                 published: true
             }
         ]);
+        expect(getPublishedQuestions(TRIVIA_QUESTIONS)).toEqual([]);
+        expect(getPublishedQuestions(SIMPLE_QUESTIONS_2)).toEqual(
+            BACKUP_SIMPLE_QUESTIONS_2
+        );
+        expect(getPublishedQuestions(EMPTY_QUESTIONS)).toEqual([
+            {
+                id: 1,
+                name: "Empty 1",
+                body: "This question is not empty, right?",
+                type: "multiple_choice_question",
+                options: ["correct", "it is", "not"],
+                expected: "correct",
+                points: 5,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Empty 2",
+                body: "",
+                type: "multiple_choice_question",
+                options: ["this", "one", "is", "not", "empty", "either"],
+                expected: "one",
+                points: 5,
+                published: true
+            },
+            {
+                id: 3,
+                name: "Empty 3",
+                body: "This questions is not empty either!",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 5,
+                published: true
+            },
+            {
+                id: 4,
+                name: "Empty 4",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "Even this one is not empty",
+                points: 5,
+                published: true
+            }
+        ]);
+    });
+
+    test("Testing the getNonEmptyQuestions functions", () => {
+        expect(getNonEmptyQuestions(BLANK_QUESTIONS)).toEqual([]);
+        expect(getNonEmptyQuestions(SIMPLE_QUESTIONS)).toEqual(
+            BACKUP_SIMPLE_QUESTIONS
+        );
+        expect(getNonEmptyQuestions(TRIVIA_QUESTIONS)).toEqual(
+            BACKUP_TRIVIA_QUESTIONS
+        );
+        expect(getNonEmptyQuestions(SIMPLE_QUESTIONS_2)).toEqual(
+            BACKUP_SIMPLE_QUESTIONS_2
+        );
+        expect(getNonEmptyQuestions(EMPTY_QUESTIONS)).toEqual([
+            {
+                id: 1,
+                name: "Empty 1",
+                body: "This question is not empty, right?",
+                type: "multiple_choice_question",
+                options: ["correct", "it is", "not"],
+                expected: "correct",
+                points: 5,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Empty 2",
+                body: "",
+                type: "multiple_choice_question",
+                options: ["this", "one", "is", "not", "empty", "either"],
+                expected: "one",
+                points: 5,
+                published: true
+            },
+            {
+                id: 3,
+                name: "Empty 3",
+                body: "This questions is not empty either!",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 5,
+                published: true
+            },
+            {
+                id: 4,
+                name: "Empty 4",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "Even this one is not empty",
+                points: 5,
+                published: true
+            }
+        ]);
+    });
+
+    test("Testing the findQuestion function", () => {
+        expect(findQuestion(BLANK_QUESTIONS, 1)).toEqual(BLANK_QUESTIONS[0]);
+        expect(findQuestion(BLANK_QUESTIONS, 47)).toEqual(BLANK_QUESTIONS[1]);
+        expect(findQuestion(BLANK_QUESTIONS, 2)).toEqual(BLANK_QUESTIONS[2]);
+        expect(findQuestion(BLANK_QUESTIONS, 3)).toEqual(null);
+        expect(findQuestion(SIMPLE_QUESTIONS, 1)).toEqual(SIMPLE_QUESTIONS[0]);
+        expect(findQuestion(SIMPLE_QUESTIONS, 2)).toEqual(SIMPLE_QUESTIONS[1]);
+        expect(findQuestion(SIMPLE_QUESTIONS, 5)).toEqual(SIMPLE_QUESTIONS[2]);
+        expect(findQuestion(SIMPLE_QUESTIONS, 9)).toEqual(SIMPLE_QUESTIONS[3]);
+        expect(findQuestion(SIMPLE_QUESTIONS, 6)).toEqual(null);
+        expect(findQuestion(SIMPLE_QUESTIONS_2, 478)).toEqual(
+            SIMPLE_QUESTIONS_2[0]
+        );
+        expect(findQuestion([], 0)).toEqual(null);
+    });
+
+    test("Testing the removeQuestion", () => {
+        expect(removeQuestion(BLANK_QUESTIONS, 1)).toEqual([
+            {
+                id: 47,
+                name: "My New Question",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Question 2",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            }
+        ]);
+        expect(removeQuestion(BLANK_QUESTIONS, 47)).toEqual([
+            {
+                id: 1,
+                name: "Question 1",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Question 2",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            }
+        ]);
+        expect(removeQuestion(BLANK_QUESTIONS, 2)).toEqual([
+            {
+                id: 1,
+                name: "Question 1",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 47,
+                name: "My New Question",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            }
+        ]);
+        expect(removeQuestion(SIMPLE_QUESTIONS, 9)).toEqual([
+            {
+                id: 1,
+                name: "Addition",
+                body: "What is 2+2?",
+                type: "short_answer_question",
+                options: [],
+                expected: "4",
+                points: 1,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Letters",
+                body: "What is the last letter of the English alphabet?",
+                type: "short_answer_question",
+                options: [],
+                expected: "Z",
+                points: 1,
+                published: false
+            },
+            {
+                id: 5,
+                name: "Colors",
+                body: "Which of these is a color?",
+                type: "multiple_choice_question",
+                options: ["red", "apple", "firetruck"],
+                expected: "red",
+                points: 1,
+                published: true
+            }
+        ]);
+        expect(removeQuestion(SIMPLE_QUESTIONS, 5)).toEqual([
+            {
+                id: 1,
+                name: "Addition",
+                body: "What is 2+2?",
+                type: "short_answer_question",
+                options: [],
+                expected: "4",
+                points: 1,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Letters",
+                body: "What is the last letter of the English alphabet?",
+                type: "short_answer_question",
+                options: [],
+                expected: "Z",
+                points: 1,
+                published: false
+            },
+            {
+                id: 9,
+                name: "Shapes",
+                body: "What shape can you make with one line?",
+                type: "multiple_choice_question",
+                options: ["square", "triangle", "circle"],
+                expected: "circle",
+                points: 2,
+                published: false
+            }
+        ]);
+    });
+
+    test("Testing the getNames function", () => {
+        expect(getNames(BLANK_QUESTIONS)).toEqual([
+            "Question 1",
+            "My New Question",
+            "Question 2"
+        ]);
+        expect(getNames(SIMPLE_QUESTIONS)).toEqual([
+            "Addition",
+            "Letters",
+            "Colors",
+            "Shapes"
+        ]);
+        expect(getNames(TRIVIA_QUESTIONS)).toEqual([
+            "Mascot",
+            "Motto",
+            "Goats"
+        ]);
+        expect(getNames(SIMPLE_QUESTIONS_2)).toEqual([
+            "Students",
+            "Importance",
+            "Sentience",
+            "Danger",
+            "Listening"
+        ]);
+        expect(getNames(EMPTY_QUESTIONS)).toEqual([
+            "Empty 1",
+            "Empty 2",
+            "Empty 3",
+            "Empty 4",
+            "Empty 5 (Actual)"
+        ]);
+    });
+
+    test("Testing the sumPoints function", () => {
+        expect(sumPoints(BLANK_QUESTIONS)).toEqual(3);
+        expect(sumPoints(SIMPLE_QUESTIONS)).toEqual(5);
+        expect(sumPoints(TRIVIA_QUESTIONS)).toEqual(20);
+        expect(sumPoints(EMPTY_QUESTIONS)).toEqual(25);
+        expect(sumPoints(SIMPLE_QUESTIONS_2)).toEqual(300);
+    });
+
+    test("Testing the sumPublishedPoints function", () => {
+        expect(sumPublishedPoints(BLANK_QUESTIONS)).toEqual(0);
+        expect(sumPublishedPoints(SIMPLE_QUESTIONS)).toEqual(2);
+        expect(sumPublishedPoints(TRIVIA_QUESTIONS)).toEqual(0);
+        expect(sumPublishedPoints(EMPTY_QUESTIONS)).toEqual(20);
+        expect(sumPublishedPoints(SIMPLE_QUESTIONS_2)).toEqual(300);
+    });
+
+    test("Testing the toCSV function", () => {
+        expect(toCSV(BLANK_QUESTIONS)).toEqual(`id,name,options,points,published
+1,Question 1,0,1,false
+47,My New Question,0,1,false
+2,Question 2,0,1,false`);
+        expect(toCSV(SIMPLE_QUESTIONS))
+            .toEqual(`id,name,options,points,published
+1,Addition,0,1,true
+2,Letters,0,1,false
+5,Colors,3,1,true
+9,Shapes,3,2,false`);
+        expect(toCSV(TRIVIA_QUESTIONS))
+            .toEqual(`id,name,options,points,published
+1,Mascot,3,7,false
+2,Motto,3,3,false
+3,Goats,3,10,false`);
+        expect(toCSV(EMPTY_QUESTIONS)).toEqual(`id,name,options,points,published
+1,Empty 1,3,5,true
+2,Empty 2,6,5,true
+3,Empty 3,0,5,true
+4,Empty 4,0,5,true
+5,Empty 5 (Actual),0,5,false`);
+        expect(toCSV(SIMPLE_QUESTIONS_2))
+            .toEqual(`id,name,options,points,published
+478,Students,0,53,true
+1937,Importance,0,47,true
+479,Sentience,0,40,true
+777,Danger,0,60,true
+1937,Listening,0,100,true`);
+    });
+
+    test("Testing the makeAnswers function", () => {
+        expect(makeAnswers(BLANK_QUESTIONS)).toEqual([
+            { questionId: 1, correct: false, text: "", submitted: false },
+            { questionId: 47, correct: false, text: "", submitted: false },
+            { questionId: 2, correct: false, text: "", submitted: false }
+        ]);
+        expect(makeAnswers(SIMPLE_QUESTIONS)).toEqual([
+            { questionId: 1, correct: false, text: "", submitted: false },
+            { questionId: 2, correct: false, text: "", submitted: false },
+            { questionId: 5, correct: false, text: "", submitted: false },
+            { questionId: 9, correct: false, text: "", submitted: false }
+        ]);
+        expect(makeAnswers(TRIVIA_QUESTIONS)).toEqual([
+            { questionId: 1, correct: false, text: "", submitted: false },
+            { questionId: 2, correct: false, text: "", submitted: false },
+            { questionId: 3, correct: false, text: "", submitted: false }
+        ]);
+        expect(makeAnswers(SIMPLE_QUESTIONS_2)).toEqual([
+            { questionId: 478, correct: false, text: "", submitted: false },
+            { questionId: 1937, correct: false, text: "", submitted: false },
+            { questionId: 479, correct: false, text: "", submitted: false },
+            { questionId: 777, correct: false, text: "", submitted: false },
+            { questionId: 1937, correct: false, text: "", submitted: false }
+        ]);
+        expect(makeAnswers(EMPTY_QUESTIONS)).toEqual([
+            { questionId: 1, correct: false, text: "", submitted: false },
+            { questionId: 2, correct: false, text: "", submitted: false },
+            { questionId: 3, correct: false, text: "", submitted: false },
+            { questionId: 4, correct: false, text: "", submitted: false },
+            { questionId: 5, correct: false, text: "", submitted: false }
+        ]);
+    });
+
+    test("Testing the publishAll function", () => {
+        expect(publishAll(BLANK_QUESTIONS)).toEqual([
+            {
+                id: 1,
+                name: "Question 1",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: true
+            },
+            {
+                id: 47,
+                name: "My New Question",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Question 2",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: true
+            }
+        ]);
+        expect(publishAll(SIMPLE_QUESTIONS)).toEqual([
+            {
+                id: 1,
+                name: "Addition",
+                body: "What is 2+2?",
+                type: "short_answer_question",
+                options: [],
+                expected: "4",
+                points: 1,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Letters",
+                body: "What is the last letter of the English alphabet?",
+                type: "short_answer_question",
+                options: [],
+                expected: "Z",
+                points: 1,
+                published: true
+            },
+            {
+                id: 5,
+                name: "Colors",
+                body: "Which of these is a color?",
+                type: "multiple_choice_question",
+                options: ["red", "apple", "firetruck"],
+                expected: "red",
+                points: 1,
+                published: true
+            },
+            {
+                id: 9,
+                name: "Shapes",
+                body: "What shape can you make with one line?",
+                type: "multiple_choice_question",
+                options: ["square", "triangle", "circle"],
+                expected: "circle",
+                points: 2,
+                published: true
+            }
+        ]);
+        expect(publishAll(TRIVIA_QUESTIONS)).toEqual([
+            {
+                id: 1,
+                name: "Mascot",
+                body: "What is the name of the UD Mascot?",
+                type: "multiple_choice_question",
+                options: ["Bluey", "YoUDee", "Charles the Wonder Dog"],
+                expected: "YoUDee",
+                points: 7,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Motto",
+                body: "What is the University of Delaware's motto?",
+                type: "multiple_choice_question",
+                options: [
+                    "Knowledge is the light of the mind",
+                    "Just U Do it",
+                    "Nothing, what's the motto with you?"
+                ],
+                expected: "Knowledge is the light of the mind",
+                points: 3,
+                published: true
+            },
+            {
+                id: 3,
+                name: "Goats",
+                body: "How many goats are there usually on the Green?",
+                type: "multiple_choice_question",
+                options: [
+                    "Zero, why would there be goats on the green?",
+                    "18420",
+                    "Two"
+                ],
+                expected: "Two",
+                points: 10,
+                published: true
+            }
+        ]);
+        expect(publishAll(EMPTY_QUESTIONS)).toEqual([
+            {
+                id: 1,
+                name: "Empty 1",
+                body: "This question is not empty, right?",
+                type: "multiple_choice_question",
+                options: ["correct", "it is", "not"],
+                expected: "correct",
+                points: 5,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Empty 2",
+                body: "",
+                type: "multiple_choice_question",
+                options: ["this", "one", "is", "not", "empty", "either"],
+                expected: "one",
+                points: 5,
+                published: true
+            },
+            {
+                id: 3,
+                name: "Empty 3",
+                body: "This questions is not empty either!",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 5,
+                published: true
+            },
+            {
+                id: 4,
+                name: "Empty 4",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "Even this one is not empty",
+                points: 5,
+                published: true
+            },
+            {
+                id: 5,
+                name: "Empty 5 (Actual)",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 5,
+                published: true
+            }
+        ]);
+        expect(publishAll(SIMPLE_QUESTIONS_2)).toEqual(SIMPLE_QUESTIONS_2);
+    });
+
+    test("Testing the sameType function", () => {
+        expect(sameType([])).toEqual(true);
+        expect(sameType(BLANK_QUESTIONS)).toEqual(false);
+        expect(sameType(SIMPLE_QUESTIONS)).toEqual(false);
+        expect(sameType(TRIVIA_QUESTIONS)).toEqual(true);
+        expect(sameType(EMPTY_QUESTIONS)).toEqual(false);
+        expect(sameType(SIMPLE_QUESTIONS_2)).toEqual(true);
+    });
+
+    test("Testing the addNewQuestion function", () => {
+        expect(
+            addNewQuestion([], 142, "A new question", "short_answer_question")
+        ).toEqual([NEW_BLANK_QUESTION]);
+        expect(
+            addNewQuestion(
+                BLANK_QUESTIONS,
+                142,
+                "A new question",
+                "short_answer_question"
+            )
+        ).toEqual([...BLANK_QUESTIONS, NEW_BLANK_QUESTION]);
+        expect(
+            addNewQuestion(
+                TRIVIA_QUESTIONS,
+                449,
+                "Colors",
+                "multiple_choice_question"
+            )
+        ).toEqual([...TRIVIA_QUESTIONS, NEW_TRIVIA_QUESTION]);
+    });
+
+    test("Testing the renameQuestionById function", () => {
+        expect(renameQuestionById(BLANK_QUESTIONS, 1, "New Name")).toEqual([
+            {
+                id: 1,
+                name: "New Name",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 47,
+                name: "My New Question",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Question 2",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            }
+        ]);
+        expect(renameQuestionById(BLANK_QUESTIONS, 47, "Another Name")).toEqual(
+            [
+                {
+                    id: 1,
+                    name: "Question 1",
+                    body: "",
+                    type: "multiple_choice_question",
+                    options: [],
+                    expected: "",
+                    points: 1,
+                    published: false
+                },
+                {
+                    id: 47,
+                    name: "Another Name",
+                    body: "",
+                    type: "multiple_choice_question",
+                    options: [],
+                    expected: "",
+                    points: 1,
+                    published: false
+                },
+                {
+                    id: 2,
+                    name: "Question 2",
+                    body: "",
+                    type: "short_answer_question",
+                    options: [],
+                    expected: "",
+                    points: 1,
+                    published: false
+                }
+            ]
+        );
+        expect(renameQuestionById(SIMPLE_QUESTIONS, 5, "Colours")).toEqual([
+            {
+                id: 1,
+                name: "Addition",
+                body: "What is 2+2?",
+                type: "short_answer_question",
+                options: [],
+                expected: "4",
+                points: 1,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Letters",
+                body: "What is the last letter of the English alphabet?",
+                type: "short_answer_question",
+                options: [],
+                expected: "Z",
+                points: 1,
+                published: false
+            },
+            {
+                id: 5,
+                name: "Colours",
+                body: "Which of these is a color?",
+                type: "multiple_choice_question",
+                options: ["red", "apple", "firetruck"],
+                expected: "red",
+                points: 1,
+                published: true
+            },
+            {
+                id: 9,
+                name: "Shapes",
+                body: "What shape can you make with one line?",
+                type: "multiple_choice_question",
+                options: ["square", "triangle", "circle"],
+                expected: "circle",
+                points: 2,
+                published: false
+            }
+        ]);
+    });
+
+    test("Test the changeQuestionTypeById function", () => {
+        expect(
+            changeQuestionTypeById(
+                BLANK_QUESTIONS,
+                1,
+                "multiple_choice_question"
+            )
+        ).toEqual(BLANK_QUESTIONS);
+        expect(
+            changeQuestionTypeById(BLANK_QUESTIONS, 1, "short_answer_question")
+        ).toEqual([
+            {
+                id: 1,
+                name: "Question 1",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 47,
+                name: "My New Question",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Question 2",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            }
+        ]);
+        expect(
+            changeQuestionTypeById(BLANK_QUESTIONS, 47, "short_answer_question")
+        ).toEqual([
+            {
+                id: 1,
+                name: "Question 1",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 47,
+                name: "My New Question",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Question 2",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            }
+        ]);
+        expect(
+            changeQuestionTypeById(TRIVIA_QUESTIONS, 3, "short_answer_question")
+        ).toEqual([
+            {
+                id: 1,
+                name: "Mascot",
+                body: "What is the name of the UD Mascot?",
+                type: "multiple_choice_question",
+                options: ["Bluey", "YoUDee", "Charles the Wonder Dog"],
+                expected: "YoUDee",
+                points: 7,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Motto",
+                body: "What is the University of Delaware's motto?",
+                type: "multiple_choice_question",
+                options: [
+                    "Knowledge is the light of the mind",
+                    "Just U Do it",
+                    "Nothing, what's the motto with you?"
+                ],
+                expected: "Knowledge is the light of the mind",
+                points: 3,
+                published: false
+            },
+            {
+                id: 3,
+                name: "Goats",
+                body: "How many goats are there usually on the Green?",
+                type: "short_answer_question",
+                options: [],
+                expected: "Two",
+                points: 10,
+                published: false
+            }
+        ]);
+    });
+
+    test("Testing the addEditQuestionOption function", () => {
+        expect(editOption(BLANK_QUESTIONS, 1, -1, "NEW OPTION")).toEqual([
+            {
+                id: 1,
+                name: "Question 1",
+                body: "",
+                type: "multiple_choice_question",
+                options: ["NEW OPTION"],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 47,
+                name: "My New Question",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Question 2",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            }
+        ]);
+        expect(editOption(BLANK_QUESTIONS, 47, -1, "Another option")).toEqual([
+            {
+                id: 1,
+                name: "Question 1",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 47,
+                name: "My New Question",
+                body: "",
+                type: "multiple_choice_question",
+                options: ["Another option"],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Question 2",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            }
+        ]);
+        expect(editOption(SIMPLE_QUESTIONS, 5, -1, "newspaper")).toEqual([
+            {
+                id: 1,
+                name: "Addition",
+                body: "What is 2+2?",
+                type: "short_answer_question",
+                options: [],
+                expected: "4",
+                points: 1,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Letters",
+                body: "What is the last letter of the English alphabet?",
+                type: "short_answer_question",
+                options: [],
+                expected: "Z",
+                points: 1,
+                published: false
+            },
+            {
+                id: 5,
+                name: "Colors",
+                body: "Which of these is a color?",
+                type: "multiple_choice_question",
+                options: ["red", "apple", "firetruck", "newspaper"],
+                expected: "red",
+                points: 1,
+                published: true
+            },
+            {
+                id: 9,
+                name: "Shapes",
+                body: "What shape can you make with one line?",
+                type: "multiple_choice_question",
+                options: ["square", "triangle", "circle"],
+                expected: "circle",
+                points: 2,
+                published: false
+            }
+        ]);
+        expect(editOption(SIMPLE_QUESTIONS, 5, 0, "newspaper")).toEqual([
+            {
+                id: 1,
+                name: "Addition",
+                body: "What is 2+2?",
+                type: "short_answer_question",
+                options: [],
+                expected: "4",
+                points: 1,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Letters",
+                body: "What is the last letter of the English alphabet?",
+                type: "short_answer_question",
+                options: [],
+                expected: "Z",
+                points: 1,
+                published: false
+            },
+            {
+                id: 5,
+                name: "Colors",
+                body: "Which of these is a color?",
+                type: "multiple_choice_question",
+                options: ["newspaper", "apple", "firetruck"],
+                expected: "red",
+                points: 1,
+                published: true
+            },
+            {
+                id: 9,
+                name: "Shapes",
+                body: "What shape can you make with one line?",
+                type: "multiple_choice_question",
+                options: ["square", "triangle", "circle"],
+                expected: "circle",
+                points: 2,
+                published: false
+            }
+        ]);
+
+        expect(editOption(SIMPLE_QUESTIONS, 5, 2, "newspaper")).toEqual([
+            {
+                id: 1,
+                name: "Addition",
+                body: "What is 2+2?",
+                type: "short_answer_question",
+                options: [],
+                expected: "4",
+                points: 1,
+                published: true
+            },
+            {
+                id: 2,
+                name: "Letters",
+                body: "What is the last letter of the English alphabet?",
+                type: "short_answer_question",
+                options: [],
+                expected: "Z",
+                points: 1,
+                published: false
+            },
+            {
+                id: 5,
+                name: "Colors",
+                body: "Which of these is a color?",
+                type: "multiple_choice_question",
+                options: ["red", "apple", "newspaper"],
+                expected: "red",
+                points: 1,
+                published: true
+            },
+            {
+                id: 9,
+                name: "Shapes",
+                body: "What shape can you make with one line?",
+                type: "multiple_choice_question",
+                options: ["square", "triangle", "circle"],
+                expected: "circle",
+                points: 2,
+                published: false
+            }
+        ]);
+    });
+
+    test("Testing the duplicateQuestionInArray function", () => {
+        expect(duplicateQuestionInArray(BLANK_QUESTIONS, 1, 27)).toEqual([
+            {
+                id: 1,
+                name: "Question 1",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 27,
+                name: "Copy of Question 1",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 47,
+                name: "My New Question",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Question 2",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            }
+        ]);
+        expect(duplicateQuestionInArray(BLANK_QUESTIONS, 47, 19)).toEqual([
+            {
+                id: 1,
+                name: "Question 1",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 47,
+                name: "My New Question",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 19,
+                name: "Copy of My New Question",
+                body: "",
+                type: "multiple_choice_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Question 2",
+                body: "",
+                type: "short_answer_question",
+                options: [],
+                expected: "",
+                points: 1,
+                published: false
+            }
+        ]);
+        expect(duplicateQuestionInArray(TRIVIA_QUESTIONS, 3, 111)).toEqual([
+            {
+                id: 1,
+                name: "Mascot",
+                body: "What is the name of the UD Mascot?",
+                type: "multiple_choice_question",
+                options: ["Bluey", "YoUDee", "Charles the Wonder Dog"],
+                expected: "YoUDee",
+                points: 7,
+                published: false
+            },
+            {
+                id: 2,
+                name: "Motto",
+                body: "What is the University of Delaware's motto?",
+                type: "multiple_choice_question",
+                options: [
+                    "Knowledge is the light of the mind",
+                    "Just U Do it",
+                    "Nothing, what's the motto with you?"
+                ],
+                expected: "Knowledge is the light of the mind",
+                points: 3,
+                published: false
+            },
+            {
+                id: 3,
+                name: "Goats",
+                body: "How many goats are there usually on the Green?",
+                type: "multiple_choice_question",
+                options: [
+                    "Zero, why would there be goats on the green?",
+                    "18420",
+                    "Two"
+                ],
+                expected: "Two",
+                points: 10,
+                published: false
+            },
+            {
+                id: 111,
+                name: "Copy of Goats",
+                body: "How many goats are there usually on the Green?",
+                type: "multiple_choice_question",
+                options: [
+                    "Zero, why would there be goats on the green?",
+                    "18420",
+                    "Two"
+                ],
+                expected: "Two",
+                points: 10,
+                published: false
+            }
+        ]);
     });
 
     afterEach(() => {
         expect(BLANK_QUESTIONS).toEqual(BACKUP_BLANK_QUESTIONS);
         expect(SIMPLE_QUESTIONS).toEqual(BACKUP_SIMPLE_QUESTIONS);
+        expect(TRIVIA_QUESTIONS).toEqual(BACKUP_TRIVIA_QUESTIONS);
+        expect(SIMPLE_QUESTIONS_2).toEqual(BACKUP_SIMPLE_QUESTIONS_2);
+        expect(EMPTY_QUESTIONS).toEqual(BACKUP_EMPTY_QUESTIONS);
     });
 });

From a368ad06a9847e4cb04fc2d544ff49997db54e90 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sat, 19 Feb 2022 13:52:24 -0500
Subject: [PATCH 34/46] Forgot the task record!

---
 public/tasks/task-nested.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 public/tasks/task-nested.md

diff --git a/public/tasks/task-nested.md b/public/tasks/task-nested.md
new file mode 100644
index 0000000000..6d29f9369f
--- /dev/null
+++ b/public/tasks/task-nested.md
@@ -0,0 +1,5 @@
+# Task - Nested
+
+Version: 0.0.1
+
+Implement functions that work with nested arrays and objects immutably.

From 304184e9c70c1ed35eff2a7e522c3e71d9204d17 Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Tue, 1 Mar 2022 16:38:02 -0500
Subject: [PATCH 35/46] Fix typo in editOption test, and missing return type
 for editOption

---
 src/nested.test.ts | 2 +-
 src/nested.ts      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/nested.test.ts b/src/nested.test.ts
index 3d2b75406d..572a7a028d 100644
--- a/src/nested.test.ts
+++ b/src/nested.test.ts
@@ -893,7 +893,7 @@ describe("Testing the Question[] functions", () => {
         ]);
     });
 
-    test("Testing the addEditQuestionOption function", () => {
+    test("Testing the editOption function", () => {
         expect(editOption(BLANK_QUESTIONS, 1, -1, "NEW OPTION")).toEqual([
             {
                 id: 1,
diff --git a/src/nested.ts b/src/nested.ts
index 7934ec1741..562b6ca0df 100644
--- a/src/nested.ts
+++ b/src/nested.ts
@@ -162,7 +162,7 @@ export function editOption(
     targetId: number,
     targetOptionIndex: number,
     newOption: string
-) {
+): Question[] {
     return [];
 }
 

From 1b76b8050daddd7c26e8cb372b2ad710974a66be Mon Sep 17 00:00:00 2001
From: Austin Cory Bart <acbart@vt.edu>
Date: Sat, 24 Aug 2024 13:33:40 -0400
Subject: [PATCH 36/46] Fix formatting

---
 src/nested.test.ts | 338 +++++++++++++++++++++++----------------------
 1 file changed, 173 insertions(+), 165 deletions(-)

diff --git a/src/nested.test.ts b/src/nested.test.ts
index 572a7a028d..7f52bfdf94 100644
--- a/src/nested.test.ts
+++ b/src/nested.test.ts
@@ -15,7 +15,7 @@ import {
     renameQuestionById,
     changeQuestionTypeById,
     editOption,
-    duplicateQuestionInArray
+    duplicateQuestionInArray,
 } from "./nested";
 import testQuestionData from "./data/questions.json";
 import backupQuestionData from "./data/questions.json";
@@ -25,7 +25,7 @@ const {
     SIMPLE_QUESTIONS,
     TRIVIA_QUESTIONS,
     EMPTY_QUESTIONS,
-    SIMPLE_QUESTIONS_2
+    SIMPLE_QUESTIONS_2,
 }: Record<string, Question[]> =
     // Typecast the test data that we imported to be a record matching
     //  strings to the question list
@@ -37,7 +37,7 @@ const {
     SIMPLE_QUESTIONS: BACKUP_SIMPLE_QUESTIONS,
     TRIVIA_QUESTIONS: BACKUP_TRIVIA_QUESTIONS,
     EMPTY_QUESTIONS: BACKUP_EMPTY_QUESTIONS,
-    SIMPLE_QUESTIONS_2: BACKUP_SIMPLE_QUESTIONS_2
+    SIMPLE_QUESTIONS_2: BACKUP_SIMPLE_QUESTIONS_2,
 }: Record<string, Question[]> = backupQuestionData as Record<
     string,
     Question[]
@@ -51,7 +51,7 @@ const NEW_BLANK_QUESTION = {
     options: [],
     expected: "",
     points: 1,
-    published: false
+    published: false,
 };
 
 const NEW_TRIVIA_QUESTION = {
@@ -66,7 +66,7 @@ const NEW_TRIVIA_QUESTION = {
     options: ["Black, like my soul", "Blue again, we're tricky.", "#FFD200"],
     expected: "#FFD200",*/
     points: 1,
-    published: false
+    published: false,
 };
 
 ////////////////////////////////////////////
@@ -76,7 +76,7 @@ describe("Testing the Question[] functions", () => {
     //////////////////////////////////
     // getPublishedQuestions
 
-    test("Testing the getPublishedQuestions function", () => {
+    test("(3 pts) Testing the getPublishedQuestions function", () => {
         expect(getPublishedQuestions(BLANK_QUESTIONS)).toEqual([]);
         expect(getPublishedQuestions(SIMPLE_QUESTIONS)).toEqual([
             {
@@ -87,7 +87,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "4",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 5,
@@ -97,12 +97,12 @@ describe("Testing the Question[] functions", () => {
                 options: ["red", "apple", "firetruck"],
                 expected: "red",
                 points: 1,
-                published: true
-            }
+                published: true,
+            },
         ]);
         expect(getPublishedQuestions(TRIVIA_QUESTIONS)).toEqual([]);
         expect(getPublishedQuestions(SIMPLE_QUESTIONS_2)).toEqual(
-            BACKUP_SIMPLE_QUESTIONS_2
+            BACKUP_SIMPLE_QUESTIONS_2,
         );
         expect(getPublishedQuestions(EMPTY_QUESTIONS)).toEqual([
             {
@@ -113,7 +113,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["correct", "it is", "not"],
                 expected: "correct",
                 points: 5,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -123,7 +123,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["this", "one", "is", "not", "empty", "either"],
                 expected: "one",
                 points: 5,
-                published: true
+                published: true,
             },
             {
                 id: 3,
@@ -133,7 +133,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 5,
-                published: true
+                published: true,
             },
             {
                 id: 4,
@@ -143,21 +143,21 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Even this one is not empty",
                 points: 5,
-                published: true
-            }
+                published: true,
+            },
         ]);
     });
 
-    test("Testing the getNonEmptyQuestions functions", () => {
+    test("(3 pts) Testing the getNonEmptyQuestions functions", () => {
         expect(getNonEmptyQuestions(BLANK_QUESTIONS)).toEqual([]);
         expect(getNonEmptyQuestions(SIMPLE_QUESTIONS)).toEqual(
-            BACKUP_SIMPLE_QUESTIONS
+            BACKUP_SIMPLE_QUESTIONS,
         );
         expect(getNonEmptyQuestions(TRIVIA_QUESTIONS)).toEqual(
-            BACKUP_TRIVIA_QUESTIONS
+            BACKUP_TRIVIA_QUESTIONS,
         );
         expect(getNonEmptyQuestions(SIMPLE_QUESTIONS_2)).toEqual(
-            BACKUP_SIMPLE_QUESTIONS_2
+            BACKUP_SIMPLE_QUESTIONS_2,
         );
         expect(getNonEmptyQuestions(EMPTY_QUESTIONS)).toEqual([
             {
@@ -168,7 +168,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["correct", "it is", "not"],
                 expected: "correct",
                 points: 5,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -178,7 +178,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["this", "one", "is", "not", "empty", "either"],
                 expected: "one",
                 points: 5,
-                published: true
+                published: true,
             },
             {
                 id: 3,
@@ -188,7 +188,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 5,
-                published: true
+                published: true,
             },
             {
                 id: 4,
@@ -198,12 +198,12 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Even this one is not empty",
                 points: 5,
-                published: true
-            }
+                published: true,
+            },
         ]);
     });
 
-    test("Testing the findQuestion function", () => {
+    test("(3 pts) Testing the findQuestion function", () => {
         expect(findQuestion(BLANK_QUESTIONS, 1)).toEqual(BLANK_QUESTIONS[0]);
         expect(findQuestion(BLANK_QUESTIONS, 47)).toEqual(BLANK_QUESTIONS[1]);
         expect(findQuestion(BLANK_QUESTIONS, 2)).toEqual(BLANK_QUESTIONS[2]);
@@ -214,12 +214,12 @@ describe("Testing the Question[] functions", () => {
         expect(findQuestion(SIMPLE_QUESTIONS, 9)).toEqual(SIMPLE_QUESTIONS[3]);
         expect(findQuestion(SIMPLE_QUESTIONS, 6)).toEqual(null);
         expect(findQuestion(SIMPLE_QUESTIONS_2, 478)).toEqual(
-            SIMPLE_QUESTIONS_2[0]
+            SIMPLE_QUESTIONS_2[0],
         );
         expect(findQuestion([], 0)).toEqual(null);
     });
 
-    test("Testing the removeQuestion", () => {
+    test("(3 pts) Testing the removeQuestion", () => {
         expect(removeQuestion(BLANK_QUESTIONS, 1)).toEqual([
             {
                 id: 47,
@@ -229,7 +229,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -239,8 +239,8 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(removeQuestion(BLANK_QUESTIONS, 47)).toEqual([
             {
@@ -251,7 +251,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -261,8 +261,8 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(removeQuestion(BLANK_QUESTIONS, 2)).toEqual([
             {
@@ -273,7 +273,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 47,
@@ -283,8 +283,8 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(removeQuestion(SIMPLE_QUESTIONS, 9)).toEqual([
             {
@@ -295,7 +295,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "4",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -305,7 +305,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Z",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 5,
@@ -315,8 +315,8 @@ describe("Testing the Question[] functions", () => {
                 options: ["red", "apple", "firetruck"],
                 expected: "red",
                 points: 1,
-                published: true
-            }
+                published: true,
+            },
         ]);
         expect(removeQuestion(SIMPLE_QUESTIONS, 5)).toEqual([
             {
@@ -327,7 +327,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "4",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -337,7 +337,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Z",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 9,
@@ -347,45 +347,45 @@ describe("Testing the Question[] functions", () => {
                 options: ["square", "triangle", "circle"],
                 expected: "circle",
                 points: 2,
-                published: false
-            }
+                published: false,
+            },
         ]);
     });
 
-    test("Testing the getNames function", () => {
+    test("(3 pts) Testing the getNames function", () => {
         expect(getNames(BLANK_QUESTIONS)).toEqual([
             "Question 1",
             "My New Question",
-            "Question 2"
+            "Question 2",
         ]);
         expect(getNames(SIMPLE_QUESTIONS)).toEqual([
             "Addition",
             "Letters",
             "Colors",
-            "Shapes"
+            "Shapes",
         ]);
         expect(getNames(TRIVIA_QUESTIONS)).toEqual([
             "Mascot",
             "Motto",
-            "Goats"
+            "Goats",
         ]);
         expect(getNames(SIMPLE_QUESTIONS_2)).toEqual([
             "Students",
             "Importance",
             "Sentience",
             "Danger",
-            "Listening"
+            "Listening",
         ]);
         expect(getNames(EMPTY_QUESTIONS)).toEqual([
             "Empty 1",
             "Empty 2",
             "Empty 3",
             "Empty 4",
-            "Empty 5 (Actual)"
+            "Empty 5 (Actual)",
         ]);
     });
 
-    test("Testing the sumPoints function", () => {
+    test("(3 pts) Testing the sumPoints function", () => {
         expect(sumPoints(BLANK_QUESTIONS)).toEqual(3);
         expect(sumPoints(SIMPLE_QUESTIONS)).toEqual(5);
         expect(sumPoints(TRIVIA_QUESTIONS)).toEqual(20);
@@ -393,7 +393,7 @@ describe("Testing the Question[] functions", () => {
         expect(sumPoints(SIMPLE_QUESTIONS_2)).toEqual(300);
     });
 
-    test("Testing the sumPublishedPoints function", () => {
+    test("(3 pts) Testing the sumPublishedPoints function", () => {
         expect(sumPublishedPoints(BLANK_QUESTIONS)).toEqual(0);
         expect(sumPublishedPoints(SIMPLE_QUESTIONS)).toEqual(2);
         expect(sumPublishedPoints(TRIVIA_QUESTIONS)).toEqual(0);
@@ -401,7 +401,7 @@ describe("Testing the Question[] functions", () => {
         expect(sumPublishedPoints(SIMPLE_QUESTIONS_2)).toEqual(300);
     });
 
-    test("Testing the toCSV function", () => {
+    test("(3 pts) Testing the toCSV function", () => {
         expect(toCSV(BLANK_QUESTIONS)).toEqual(`id,name,options,points,published
 1,Question 1,0,1,false
 47,My New Question,0,1,false
@@ -432,40 +432,40 @@ describe("Testing the Question[] functions", () => {
 1937,Listening,0,100,true`);
     });
 
-    test("Testing the makeAnswers function", () => {
+    test("(3 pts) Testing the makeAnswers function", () => {
         expect(makeAnswers(BLANK_QUESTIONS)).toEqual([
             { questionId: 1, correct: false, text: "", submitted: false },
             { questionId: 47, correct: false, text: "", submitted: false },
-            { questionId: 2, correct: false, text: "", submitted: false }
+            { questionId: 2, correct: false, text: "", submitted: false },
         ]);
         expect(makeAnswers(SIMPLE_QUESTIONS)).toEqual([
             { questionId: 1, correct: false, text: "", submitted: false },
             { questionId: 2, correct: false, text: "", submitted: false },
             { questionId: 5, correct: false, text: "", submitted: false },
-            { questionId: 9, correct: false, text: "", submitted: false }
+            { questionId: 9, correct: false, text: "", submitted: false },
         ]);
         expect(makeAnswers(TRIVIA_QUESTIONS)).toEqual([
             { questionId: 1, correct: false, text: "", submitted: false },
             { questionId: 2, correct: false, text: "", submitted: false },
-            { questionId: 3, correct: false, text: "", submitted: false }
+            { questionId: 3, correct: false, text: "", submitted: false },
         ]);
         expect(makeAnswers(SIMPLE_QUESTIONS_2)).toEqual([
             { questionId: 478, correct: false, text: "", submitted: false },
             { questionId: 1937, correct: false, text: "", submitted: false },
             { questionId: 479, correct: false, text: "", submitted: false },
             { questionId: 777, correct: false, text: "", submitted: false },
-            { questionId: 1937, correct: false, text: "", submitted: false }
+            { questionId: 1937, correct: false, text: "", submitted: false },
         ]);
         expect(makeAnswers(EMPTY_QUESTIONS)).toEqual([
             { questionId: 1, correct: false, text: "", submitted: false },
             { questionId: 2, correct: false, text: "", submitted: false },
             { questionId: 3, correct: false, text: "", submitted: false },
             { questionId: 4, correct: false, text: "", submitted: false },
-            { questionId: 5, correct: false, text: "", submitted: false }
+            { questionId: 5, correct: false, text: "", submitted: false },
         ]);
     });
 
-    test("Testing the publishAll function", () => {
+    test("(3 pts) Testing the publishAll function", () => {
         expect(publishAll(BLANK_QUESTIONS)).toEqual([
             {
                 id: 1,
@@ -475,7 +475,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 47,
@@ -485,7 +485,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -495,8 +495,8 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: true
-            }
+                published: true,
+            },
         ]);
         expect(publishAll(SIMPLE_QUESTIONS)).toEqual([
             {
@@ -507,7 +507,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "4",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -517,7 +517,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Z",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 5,
@@ -527,7 +527,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["red", "apple", "firetruck"],
                 expected: "red",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 9,
@@ -537,8 +537,8 @@ describe("Testing the Question[] functions", () => {
                 options: ["square", "triangle", "circle"],
                 expected: "circle",
                 points: 2,
-                published: true
-            }
+                published: true,
+            },
         ]);
         expect(publishAll(TRIVIA_QUESTIONS)).toEqual([
             {
@@ -549,7 +549,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["Bluey", "YoUDee", "Charles the Wonder Dog"],
                 expected: "YoUDee",
                 points: 7,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -559,11 +559,11 @@ describe("Testing the Question[] functions", () => {
                 options: [
                     "Knowledge is the light of the mind",
                     "Just U Do it",
-                    "Nothing, what's the motto with you?"
+                    "Nothing, what's the motto with you?",
                 ],
                 expected: "Knowledge is the light of the mind",
                 points: 3,
-                published: true
+                published: true,
             },
             {
                 id: 3,
@@ -573,12 +573,12 @@ describe("Testing the Question[] functions", () => {
                 options: [
                     "Zero, why would there be goats on the green?",
                     "18420",
-                    "Two"
+                    "Two",
                 ],
                 expected: "Two",
                 points: 10,
-                published: true
-            }
+                published: true,
+            },
         ]);
         expect(publishAll(EMPTY_QUESTIONS)).toEqual([
             {
@@ -589,7 +589,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["correct", "it is", "not"],
                 expected: "correct",
                 points: 5,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -599,7 +599,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["this", "one", "is", "not", "empty", "either"],
                 expected: "one",
                 points: 5,
-                published: true
+                published: true,
             },
             {
                 id: 3,
@@ -609,7 +609,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 5,
-                published: true
+                published: true,
             },
             {
                 id: 4,
@@ -619,7 +619,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Even this one is not empty",
                 points: 5,
-                published: true
+                published: true,
             },
             {
                 id: 5,
@@ -629,13 +629,13 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 5,
-                published: true
-            }
+                published: true,
+            },
         ]);
         expect(publishAll(SIMPLE_QUESTIONS_2)).toEqual(SIMPLE_QUESTIONS_2);
     });
 
-    test("Testing the sameType function", () => {
+    test("(3 pts) Testing the sameType function", () => {
         expect(sameType([])).toEqual(true);
         expect(sameType(BLANK_QUESTIONS)).toEqual(false);
         expect(sameType(SIMPLE_QUESTIONS)).toEqual(false);
@@ -644,29 +644,29 @@ describe("Testing the Question[] functions", () => {
         expect(sameType(SIMPLE_QUESTIONS_2)).toEqual(true);
     });
 
-    test("Testing the addNewQuestion function", () => {
+    test("(3 pts) Testing the addNewQuestion function", () => {
         expect(
-            addNewQuestion([], 142, "A new question", "short_answer_question")
+            addNewQuestion([], 142, "A new question", "short_answer_question"),
         ).toEqual([NEW_BLANK_QUESTION]);
         expect(
             addNewQuestion(
                 BLANK_QUESTIONS,
                 142,
                 "A new question",
-                "short_answer_question"
-            )
+                "short_answer_question",
+            ),
         ).toEqual([...BLANK_QUESTIONS, NEW_BLANK_QUESTION]);
         expect(
             addNewQuestion(
                 TRIVIA_QUESTIONS,
                 449,
                 "Colors",
-                "multiple_choice_question"
-            )
+                "multiple_choice_question",
+            ),
         ).toEqual([...TRIVIA_QUESTIONS, NEW_TRIVIA_QUESTION]);
     });
 
-    test("Testing the renameQuestionById function", () => {
+    test("(3 pts) Testing the renameQuestionById function", () => {
         expect(renameQuestionById(BLANK_QUESTIONS, 1, "New Name")).toEqual([
             {
                 id: 1,
@@ -676,7 +676,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 47,
@@ -686,7 +686,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -696,8 +696,8 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(renameQuestionById(BLANK_QUESTIONS, 47, "Another Name")).toEqual(
             [
@@ -709,7 +709,7 @@ describe("Testing the Question[] functions", () => {
                     options: [],
                     expected: "",
                     points: 1,
-                    published: false
+                    published: false,
                 },
                 {
                     id: 47,
@@ -719,7 +719,7 @@ describe("Testing the Question[] functions", () => {
                     options: [],
                     expected: "",
                     points: 1,
-                    published: false
+                    published: false,
                 },
                 {
                     id: 2,
@@ -729,9 +729,9 @@ describe("Testing the Question[] functions", () => {
                     options: [],
                     expected: "",
                     points: 1,
-                    published: false
-                }
-            ]
+                    published: false,
+                },
+            ],
         );
         expect(renameQuestionById(SIMPLE_QUESTIONS, 5, "Colours")).toEqual([
             {
@@ -742,7 +742,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "4",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -752,7 +752,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Z",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 5,
@@ -762,7 +762,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["red", "apple", "firetruck"],
                 expected: "red",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 9,
@@ -772,21 +772,21 @@ describe("Testing the Question[] functions", () => {
                 options: ["square", "triangle", "circle"],
                 expected: "circle",
                 points: 2,
-                published: false
-            }
+                published: false,
+            },
         ]);
     });
 
-    test("Test the changeQuestionTypeById function", () => {
+    test("(3 pts) Test the changeQuestionTypeById function", () => {
         expect(
             changeQuestionTypeById(
                 BLANK_QUESTIONS,
                 1,
-                "multiple_choice_question"
-            )
+                "multiple_choice_question",
+            ),
         ).toEqual(BLANK_QUESTIONS);
         expect(
-            changeQuestionTypeById(BLANK_QUESTIONS, 1, "short_answer_question")
+            changeQuestionTypeById(BLANK_QUESTIONS, 1, "short_answer_question"),
         ).toEqual([
             {
                 id: 1,
@@ -796,7 +796,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 47,
@@ -806,7 +806,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -816,11 +816,15 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(
-            changeQuestionTypeById(BLANK_QUESTIONS, 47, "short_answer_question")
+            changeQuestionTypeById(
+                BLANK_QUESTIONS,
+                47,
+                "short_answer_question",
+            ),
         ).toEqual([
             {
                 id: 1,
@@ -830,7 +834,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 47,
@@ -840,7 +844,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -850,11 +854,15 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(
-            changeQuestionTypeById(TRIVIA_QUESTIONS, 3, "short_answer_question")
+            changeQuestionTypeById(
+                TRIVIA_QUESTIONS,
+                3,
+                "short_answer_question",
+            ),
         ).toEqual([
             {
                 id: 1,
@@ -864,7 +872,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["Bluey", "YoUDee", "Charles the Wonder Dog"],
                 expected: "YoUDee",
                 points: 7,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -874,11 +882,11 @@ describe("Testing the Question[] functions", () => {
                 options: [
                     "Knowledge is the light of the mind",
                     "Just U Do it",
-                    "Nothing, what's the motto with you?"
+                    "Nothing, what's the motto with you?",
                 ],
                 expected: "Knowledge is the light of the mind",
                 points: 3,
-                published: false
+                published: false,
             },
             {
                 id: 3,
@@ -888,12 +896,12 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Two",
                 points: 10,
-                published: false
-            }
+                published: false,
+            },
         ]);
     });
 
-    test("Testing the editOption function", () => {
+    test("(3 pts) Testing the editOption function", () => {
         expect(editOption(BLANK_QUESTIONS, 1, -1, "NEW OPTION")).toEqual([
             {
                 id: 1,
@@ -903,7 +911,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["NEW OPTION"],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 47,
@@ -913,7 +921,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -923,8 +931,8 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(editOption(BLANK_QUESTIONS, 47, -1, "Another option")).toEqual([
             {
@@ -935,7 +943,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 47,
@@ -945,7 +953,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["Another option"],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -955,8 +963,8 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(editOption(SIMPLE_QUESTIONS, 5, -1, "newspaper")).toEqual([
             {
@@ -967,7 +975,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "4",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -977,7 +985,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Z",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 5,
@@ -987,7 +995,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["red", "apple", "firetruck", "newspaper"],
                 expected: "red",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 9,
@@ -997,8 +1005,8 @@ describe("Testing the Question[] functions", () => {
                 options: ["square", "triangle", "circle"],
                 expected: "circle",
                 points: 2,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(editOption(SIMPLE_QUESTIONS, 5, 0, "newspaper")).toEqual([
             {
@@ -1009,7 +1017,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "4",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -1019,7 +1027,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Z",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 5,
@@ -1029,7 +1037,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["newspaper", "apple", "firetruck"],
                 expected: "red",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 9,
@@ -1039,8 +1047,8 @@ describe("Testing the Question[] functions", () => {
                 options: ["square", "triangle", "circle"],
                 expected: "circle",
                 points: 2,
-                published: false
-            }
+                published: false,
+            },
         ]);
 
         expect(editOption(SIMPLE_QUESTIONS, 5, 2, "newspaper")).toEqual([
@@ -1052,7 +1060,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "4",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 2,
@@ -1062,7 +1070,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "Z",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 5,
@@ -1072,7 +1080,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["red", "apple", "newspaper"],
                 expected: "red",
                 points: 1,
-                published: true
+                published: true,
             },
             {
                 id: 9,
@@ -1082,12 +1090,12 @@ describe("Testing the Question[] functions", () => {
                 options: ["square", "triangle", "circle"],
                 expected: "circle",
                 points: 2,
-                published: false
-            }
+                published: false,
+            },
         ]);
     });
 
-    test("Testing the duplicateQuestionInArray function", () => {
+    test("(3 pts) Testing the duplicateQuestionInArray function", () => {
         expect(duplicateQuestionInArray(BLANK_QUESTIONS, 1, 27)).toEqual([
             {
                 id: 1,
@@ -1097,7 +1105,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 27,
@@ -1107,7 +1115,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 47,
@@ -1117,7 +1125,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -1127,8 +1135,8 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(duplicateQuestionInArray(BLANK_QUESTIONS, 47, 19)).toEqual([
             {
@@ -1139,7 +1147,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 47,
@@ -1149,7 +1157,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 19,
@@ -1159,7 +1167,7 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -1169,8 +1177,8 @@ describe("Testing the Question[] functions", () => {
                 options: [],
                 expected: "",
                 points: 1,
-                published: false
-            }
+                published: false,
+            },
         ]);
         expect(duplicateQuestionInArray(TRIVIA_QUESTIONS, 3, 111)).toEqual([
             {
@@ -1181,7 +1189,7 @@ describe("Testing the Question[] functions", () => {
                 options: ["Bluey", "YoUDee", "Charles the Wonder Dog"],
                 expected: "YoUDee",
                 points: 7,
-                published: false
+                published: false,
             },
             {
                 id: 2,
@@ -1191,11 +1199,11 @@ describe("Testing the Question[] functions", () => {
                 options: [
                     "Knowledge is the light of the mind",
                     "Just U Do it",
-                    "Nothing, what's the motto with you?"
+                    "Nothing, what's the motto with you?",
                 ],
                 expected: "Knowledge is the light of the mind",
                 points: 3,
-                published: false
+                published: false,
             },
             {
                 id: 3,
@@ -1205,11 +1213,11 @@ describe("Testing the Question[] functions", () => {
                 options: [
                     "Zero, why would there be goats on the green?",
                     "18420",
-                    "Two"
+                    "Two",
                 ],
                 expected: "Two",
                 points: 10,
-                published: false
+                published: false,
             },
             {
                 id: 111,
@@ -1219,12 +1227,12 @@ describe("Testing the Question[] functions", () => {
                 options: [
                     "Zero, why would there be goats on the green?",
                     "18420",
-                    "Two"
+                    "Two",
                 ],
                 expected: "Two",
                 points: 10,
-                published: false
-            }
+                published: false,
+            },
         ]);
     });
 

From 80f1cf6ecfc7e83533d76aa3a68e364f2f0e0614 Mon Sep 17 00:00:00 2001
From: Greg Nelson <gln@georgetown.edu>
Date: Tue, 17 Sep 2024 12:48:04 -0400
Subject: [PATCH 37/46] Update HtmlCss.test.tsx

---
 src/HtmlCss.test.tsx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/HtmlCss.test.tsx b/src/HtmlCss.test.tsx
index 320cb97524..84d76db400 100644
--- a/src/HtmlCss.test.tsx
+++ b/src/HtmlCss.test.tsx
@@ -4,10 +4,10 @@ import App from "./App";
 import userEvent from "@testing-library/user-event";
 
 describe("Some HTML Elements are added.", () => {
-    test("(2 pts) There is a header", () => {
+    test("(2 pts) There is a heading", () => {
         render(<App />);
-        const header = screen.getByRole("heading");
-        expect(header).toBeInTheDocument();
+        const heading = screen.getAllByRole("heading");
+        expect(heading[0]).toBeInTheDocument();
     });
 
     test("(2 pts) There is an image with alt text", () => {

From ae19e0f49b735fbae3265ca0fb4cd81014f7cbe5 Mon Sep 17 00:00:00 2001
From: Greg Nelson <gregory.nelson@maine.edu>
Date: Thu, 17 Oct 2024 11:59:30 -0400
Subject: [PATCH 38/46] reduced workload by half

---
 src/nested.test.ts | 327 ---------------------------------------------
 src/nested.ts      |  82 ++----------
 2 files changed, 9 insertions(+), 400 deletions(-)

diff --git a/src/nested.test.ts b/src/nested.test.ts
index 7f52bfdf94..61b0282318 100644
--- a/src/nested.test.ts
+++ b/src/nested.test.ts
@@ -5,17 +5,11 @@ import {
     findQuestion,
     removeQuestion,
     getNames,
-    sumPoints,
-    sumPublishedPoints,
-    toCSV,
     makeAnswers,
     publishAll,
-    sameType,
     addNewQuestion,
     renameQuestionById,
-    changeQuestionTypeById,
     editOption,
-    duplicateQuestionInArray,
 } from "./nested";
 import testQuestionData from "./data/questions.json";
 import backupQuestionData from "./data/questions.json";
@@ -385,53 +379,6 @@ describe("Testing the Question[] functions", () => {
         ]);
     });
 
-    test("(3 pts) Testing the sumPoints function", () => {
-        expect(sumPoints(BLANK_QUESTIONS)).toEqual(3);
-        expect(sumPoints(SIMPLE_QUESTIONS)).toEqual(5);
-        expect(sumPoints(TRIVIA_QUESTIONS)).toEqual(20);
-        expect(sumPoints(EMPTY_QUESTIONS)).toEqual(25);
-        expect(sumPoints(SIMPLE_QUESTIONS_2)).toEqual(300);
-    });
-
-    test("(3 pts) Testing the sumPublishedPoints function", () => {
-        expect(sumPublishedPoints(BLANK_QUESTIONS)).toEqual(0);
-        expect(sumPublishedPoints(SIMPLE_QUESTIONS)).toEqual(2);
-        expect(sumPublishedPoints(TRIVIA_QUESTIONS)).toEqual(0);
-        expect(sumPublishedPoints(EMPTY_QUESTIONS)).toEqual(20);
-        expect(sumPublishedPoints(SIMPLE_QUESTIONS_2)).toEqual(300);
-    });
-
-    test("(3 pts) Testing the toCSV function", () => {
-        expect(toCSV(BLANK_QUESTIONS)).toEqual(`id,name,options,points,published
-1,Question 1,0,1,false
-47,My New Question,0,1,false
-2,Question 2,0,1,false`);
-        expect(toCSV(SIMPLE_QUESTIONS))
-            .toEqual(`id,name,options,points,published
-1,Addition,0,1,true
-2,Letters,0,1,false
-5,Colors,3,1,true
-9,Shapes,3,2,false`);
-        expect(toCSV(TRIVIA_QUESTIONS))
-            .toEqual(`id,name,options,points,published
-1,Mascot,3,7,false
-2,Motto,3,3,false
-3,Goats,3,10,false`);
-        expect(toCSV(EMPTY_QUESTIONS)).toEqual(`id,name,options,points,published
-1,Empty 1,3,5,true
-2,Empty 2,6,5,true
-3,Empty 3,0,5,true
-4,Empty 4,0,5,true
-5,Empty 5 (Actual),0,5,false`);
-        expect(toCSV(SIMPLE_QUESTIONS_2))
-            .toEqual(`id,name,options,points,published
-478,Students,0,53,true
-1937,Importance,0,47,true
-479,Sentience,0,40,true
-777,Danger,0,60,true
-1937,Listening,0,100,true`);
-    });
-
     test("(3 pts) Testing the makeAnswers function", () => {
         expect(makeAnswers(BLANK_QUESTIONS)).toEqual([
             { questionId: 1, correct: false, text: "", submitted: false },
@@ -635,15 +582,6 @@ describe("Testing the Question[] functions", () => {
         expect(publishAll(SIMPLE_QUESTIONS_2)).toEqual(SIMPLE_QUESTIONS_2);
     });
 
-    test("(3 pts) Testing the sameType function", () => {
-        expect(sameType([])).toEqual(true);
-        expect(sameType(BLANK_QUESTIONS)).toEqual(false);
-        expect(sameType(SIMPLE_QUESTIONS)).toEqual(false);
-        expect(sameType(TRIVIA_QUESTIONS)).toEqual(true);
-        expect(sameType(EMPTY_QUESTIONS)).toEqual(false);
-        expect(sameType(SIMPLE_QUESTIONS_2)).toEqual(true);
-    });
-
     test("(3 pts) Testing the addNewQuestion function", () => {
         expect(
             addNewQuestion([], 142, "A new question", "short_answer_question"),
@@ -777,130 +715,6 @@ describe("Testing the Question[] functions", () => {
         ]);
     });
 
-    test("(3 pts) Test the changeQuestionTypeById function", () => {
-        expect(
-            changeQuestionTypeById(
-                BLANK_QUESTIONS,
-                1,
-                "multiple_choice_question",
-            ),
-        ).toEqual(BLANK_QUESTIONS);
-        expect(
-            changeQuestionTypeById(BLANK_QUESTIONS, 1, "short_answer_question"),
-        ).toEqual([
-            {
-                id: 1,
-                name: "Question 1",
-                body: "",
-                type: "short_answer_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-            {
-                id: 47,
-                name: "My New Question",
-                body: "",
-                type: "multiple_choice_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-            {
-                id: 2,
-                name: "Question 2",
-                body: "",
-                type: "short_answer_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-        ]);
-        expect(
-            changeQuestionTypeById(
-                BLANK_QUESTIONS,
-                47,
-                "short_answer_question",
-            ),
-        ).toEqual([
-            {
-                id: 1,
-                name: "Question 1",
-                body: "",
-                type: "multiple_choice_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-            {
-                id: 47,
-                name: "My New Question",
-                body: "",
-                type: "short_answer_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-            {
-                id: 2,
-                name: "Question 2",
-                body: "",
-                type: "short_answer_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-        ]);
-        expect(
-            changeQuestionTypeById(
-                TRIVIA_QUESTIONS,
-                3,
-                "short_answer_question",
-            ),
-        ).toEqual([
-            {
-                id: 1,
-                name: "Mascot",
-                body: "What is the name of the UD Mascot?",
-                type: "multiple_choice_question",
-                options: ["Bluey", "YoUDee", "Charles the Wonder Dog"],
-                expected: "YoUDee",
-                points: 7,
-                published: false,
-            },
-            {
-                id: 2,
-                name: "Motto",
-                body: "What is the University of Delaware's motto?",
-                type: "multiple_choice_question",
-                options: [
-                    "Knowledge is the light of the mind",
-                    "Just U Do it",
-                    "Nothing, what's the motto with you?",
-                ],
-                expected: "Knowledge is the light of the mind",
-                points: 3,
-                published: false,
-            },
-            {
-                id: 3,
-                name: "Goats",
-                body: "How many goats are there usually on the Green?",
-                type: "short_answer_question",
-                options: [],
-                expected: "Two",
-                points: 10,
-                published: false,
-            },
-        ]);
-    });
-
     test("(3 pts) Testing the editOption function", () => {
         expect(editOption(BLANK_QUESTIONS, 1, -1, "NEW OPTION")).toEqual([
             {
@@ -1095,147 +909,6 @@ describe("Testing the Question[] functions", () => {
         ]);
     });
 
-    test("(3 pts) Testing the duplicateQuestionInArray function", () => {
-        expect(duplicateQuestionInArray(BLANK_QUESTIONS, 1, 27)).toEqual([
-            {
-                id: 1,
-                name: "Question 1",
-                body: "",
-                type: "multiple_choice_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-            {
-                id: 27,
-                name: "Copy of Question 1",
-                body: "",
-                type: "multiple_choice_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-            {
-                id: 47,
-                name: "My New Question",
-                body: "",
-                type: "multiple_choice_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-            {
-                id: 2,
-                name: "Question 2",
-                body: "",
-                type: "short_answer_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-        ]);
-        expect(duplicateQuestionInArray(BLANK_QUESTIONS, 47, 19)).toEqual([
-            {
-                id: 1,
-                name: "Question 1",
-                body: "",
-                type: "multiple_choice_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-            {
-                id: 47,
-                name: "My New Question",
-                body: "",
-                type: "multiple_choice_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-            {
-                id: 19,
-                name: "Copy of My New Question",
-                body: "",
-                type: "multiple_choice_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-            {
-                id: 2,
-                name: "Question 2",
-                body: "",
-                type: "short_answer_question",
-                options: [],
-                expected: "",
-                points: 1,
-                published: false,
-            },
-        ]);
-        expect(duplicateQuestionInArray(TRIVIA_QUESTIONS, 3, 111)).toEqual([
-            {
-                id: 1,
-                name: "Mascot",
-                body: "What is the name of the UD Mascot?",
-                type: "multiple_choice_question",
-                options: ["Bluey", "YoUDee", "Charles the Wonder Dog"],
-                expected: "YoUDee",
-                points: 7,
-                published: false,
-            },
-            {
-                id: 2,
-                name: "Motto",
-                body: "What is the University of Delaware's motto?",
-                type: "multiple_choice_question",
-                options: [
-                    "Knowledge is the light of the mind",
-                    "Just U Do it",
-                    "Nothing, what's the motto with you?",
-                ],
-                expected: "Knowledge is the light of the mind",
-                points: 3,
-                published: false,
-            },
-            {
-                id: 3,
-                name: "Goats",
-                body: "How many goats are there usually on the Green?",
-                type: "multiple_choice_question",
-                options: [
-                    "Zero, why would there be goats on the green?",
-                    "18420",
-                    "Two",
-                ],
-                expected: "Two",
-                points: 10,
-                published: false,
-            },
-            {
-                id: 111,
-                name: "Copy of Goats",
-                body: "How many goats are there usually on the Green?",
-                type: "multiple_choice_question",
-                options: [
-                    "Zero, why would there be goats on the green?",
-                    "18420",
-                    "Two",
-                ],
-                expected: "Two",
-                points: 10,
-                published: false,
-            },
-        ]);
-    });
-
     afterEach(() => {
         expect(BLANK_QUESTIONS).toEqual(BACKUP_BLANK_QUESTIONS);
         expect(SIMPLE_QUESTIONS).toEqual(BACKUP_SIMPLE_QUESTIONS);
diff --git a/src/nested.ts b/src/nested.ts
index 562b6ca0df..78390a31a7 100644
--- a/src/nested.ts
+++ b/src/nested.ts
@@ -32,6 +32,7 @@ export function findQuestion(
 /**
  * Consumes an array of questions and returns a new array that does not contain the question
  * with the given `id`.
+ * Hint: use filter
  */
 export function removeQuestion(questions: Question[], id: number): Question[] {
     return [];
@@ -40,46 +41,12 @@ export function removeQuestion(questions: Question[], id: number): Question[] {
 /***
  * Consumes an array of questions and returns a new array containing just the names of the
  * questions, as an array.
+ * Do not modify the input array.
  */
 export function getNames(questions: Question[]): string[] {
     return [];
 }
 
-/***
- * Consumes an array of questions and returns the sum total of all their points added together.
- */
-export function sumPoints(questions: Question[]): number {
-    return 0;
-}
-
-/***
- * Consumes an array of questions and returns the sum total of the PUBLISHED questions.
- */
-export function sumPublishedPoints(questions: Question[]): number {
-    return 0;
-}
-
-/***
- * Consumes an array of questions, and produces a Comma-Separated Value (CSV) string representation.
- * A CSV is a type of file frequently used to share tabular data; we will use a single string
- * to represent the entire file. The first line of the file is the headers "id", "name", "options",
- * "points", and "published". The following line contains the value for each question, separated by
- * commas. For the `options` field, use the NUMBER of options.
- *
- * Here is an example of what this will look like (do not include the border).
- *`
-id,name,options,points,published
-1,Addition,0,1,true
-2,Letters,0,1,false
-5,Colors,3,1,true
-9,Shapes,3,2,false
-` *
- * Check the unit tests for more examples!
- */
-export function toCSV(questions: Question[]): string {
-    return "";
-}
-
 /**
  * Consumes an array of Questions and produces a corresponding array of
  * Answers. Each Question gets its own Answer, copying over the `id` as the `questionId`,
@@ -92,23 +59,17 @@ export function makeAnswers(questions: Question[]): Answer[] {
 /***
  * Consumes an array of Questions and produces a new array of questions, where
  * each question is now published, regardless of its previous published status.
+ * Hint: as usual, do not modify the input questions array
  */
 export function publishAll(questions: Question[]): Question[] {
     return [];
 }
 
-/***
- * Consumes an array of Questions and produces whether or not all the questions
- * are the same type. They can be any type, as long as they are all the SAME type.
- */
-export function sameType(questions: Question[]): boolean {
-    return false;
-}
-
 /***
  * Consumes an array of Questions and produces a new array of the same Questions,
  * except that a blank question has been added onto the end. Reuse the `makeBlankQuestion`
  * you defined in the `objects.ts` file.
+ * Hint: as usual, do not modify the input questions array
  */
 export function addNewQuestion(
     questions: Question[],
@@ -123,6 +84,8 @@ export function addNewQuestion(
  * Consumes an array of Questions and produces a new array of Questions, where all
  * the Questions are the same EXCEPT for the one with the given `targetId`. That
  * Question should be the same EXCEPT that its name should now be `newName`.
+ * Hint: as usual, do not modify the input questions array, 
+ *       to make a new copy of a question with some changes, use the ... operator
  */
 export function renameQuestionById(
     questions: Question[],
@@ -132,21 +95,6 @@ export function renameQuestionById(
     return [];
 }
 
-/***
- * Consumes an array of Questions and produces a new array of Questions, where all
- * the Questions are the same EXCEPT for the one with the given `targetId`. That
- * Question should be the same EXCEPT that its `type` should now be the `newQuestionType`
- * AND if the `newQuestionType` is no longer "multiple_choice_question" than the `options`
- * must be set to an empty list.
- */
-export function changeQuestionTypeById(
-    questions: Question[],
-    targetId: number,
-    newQuestionType: QuestionType
-): Question[] {
-    return [];
-}
-
 /**
  * Consumes an array of Questions and produces a new array of Questions, where all
  * the Questions are the same EXCEPT for the one with the given `targetId`. That
@@ -156,6 +104,8 @@ export function changeQuestionTypeById(
  *
  * Remember, if a function starts getting too complicated, think about how a helper function
  * can make it simpler! Break down complicated tasks into little pieces.
+ * 
+ * Hint: you need to use the ... operator for both the question and the options array
  */
 export function editOption(
     questions: Question[],
@@ -164,18 +114,4 @@ export function editOption(
     newOption: string
 ): Question[] {
     return [];
-}
-
-/***
- * Consumes an array of questions, and produces a new array based on the original array.
- * The only difference is that the question with id `targetId` should now be duplicated, with
- * the duplicate inserted directly after the original question. Use the `duplicateQuestion`
- * function you defined previously; the `newId` is the parameter to use for the duplicate's ID.
- */
-export function duplicateQuestionInArray(
-    questions: Question[],
-    targetId: number,
-    newId: number
-): Question[] {
-    return [];
-}
+}
\ No newline at end of file

From e69471f474cca48ba4535d98287d6734ab3e7adf Mon Sep 17 00:00:00 2001
From: gavinmpierce <157523429+gavinmpierce@users.noreply.github.com>
Date: Mon, 26 Jan 2026 21:10:06 -0500
Subject: [PATCH 39/46] Added name to App

---
 src/App.tsx | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/App.tsx b/src/App.tsx
index a8b41197f2..1f9386865b 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -7,10 +7,7 @@ function App(): React.JSX.Element {
             <header className="App-header">
                 UM COS420 with React Hooks and TypeScript
             </header>
-            <p>
-                Edit <code>src/App.tsx</code> and save. This page will
-                automatically reload.
-            </p>
+            <p>Gavin Pierce</p>
         </div>
     );
 }

From ba3bb9acb56f1a1c0a37f90d7ecbc9a2dccf6e89 Mon Sep 17 00:00:00 2001
From: gavinmpierce <157523429+gavinmpierce@users.noreply.github.com>
Date: Tue, 3 Feb 2026 20:07:31 -0500
Subject: [PATCH 40/46] task done

---
 git               |   0
 npm               |   0
 package-lock.json | 155 ++++++++++++++++++++++++++--------------------
 src/App.css       |   2 +-
 src/App.tsx       |  42 ++++++++++++-
 5 files changed, 129 insertions(+), 70 deletions(-)
 create mode 100644 git
 create mode 100644 npm

diff --git a/git b/git
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/npm b/npm
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/package-lock.json b/package-lock.json
index 8c3779f487..8c4e862b08 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -100,6 +100,7 @@
             "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.25.2.tgz",
             "integrity": "sha512-BBt3opiCOxUr9euZ5/ro/Xv8/V7yJ5bjYMqG/C1YAo8MIKAnumZalCN+msbci3Pigy4lIQfPUpfMM27HMGaYEA==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@ampproject/remapping": "^2.2.0",
                 "@babel/code-frame": "^7.24.7",
@@ -785,6 +786,7 @@
             "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.24.7.tgz",
             "integrity": "sha512-9G8GYT/dxn/D1IIKOUBmGX0mnmj46mGH9NnZyJLwtCpgh5f7D2VbuKodb+2s9m1Yavh1s7ASQN8lf0eqrb1LTw==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@babel/helper-plugin-utils": "^7.24.7"
             },
@@ -1663,6 +1665,7 @@
             "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.25.2.tgz",
             "integrity": "sha512-KQsqEAVBpU82NM/B/N9j9WOdphom1SZH3R+2V7INrQUH+V9EBFwZsEJl8eBIVeQE62FxJCc70jzEZwqU7RcVqA==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@babel/helper-annotate-as-pure": "^7.24.7",
                 "@babel/helper-module-imports": "^7.24.7",
@@ -2153,7 +2156,7 @@
             "version": "0.8.1",
             "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
             "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "@jridgewell/trace-mapping": "0.3.9"
@@ -2166,7 +2169,7 @@
             "version": "0.3.9",
             "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
             "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "@jridgewell/resolve-uri": "^3.0.3",
@@ -3273,7 +3276,7 @@
             "version": "29.6.3",
             "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz",
             "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "@sinclair/typebox": "^0.27.8"
@@ -3436,7 +3439,7 @@
             "version": "29.6.3",
             "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.6.3.tgz",
             "integrity": "sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "@jest/schemas": "^29.6.3",
@@ -3454,7 +3457,7 @@
             "version": "4.3.0",
             "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
             "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "color-convert": "^2.0.1"
@@ -3470,7 +3473,7 @@
             "version": "4.1.2",
             "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
             "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "ansi-styles": "^4.1.0",
@@ -3487,7 +3490,7 @@
             "version": "2.0.1",
             "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
             "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "color-name": "~1.1.4"
@@ -3500,14 +3503,14 @@
             "version": "1.1.4",
             "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
             "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/@jest/types/node_modules/has-flag": {
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
             "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=8"
@@ -3517,7 +3520,7 @@
             "version": "7.2.0",
             "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
             "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "has-flag": "^4.0.0"
@@ -3909,7 +3912,7 @@
             "version": "0.27.8",
             "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
             "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/@sinonjs/commons": {
@@ -4222,8 +4225,8 @@
             "version": "10.4.0",
             "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.0.tgz",
             "integrity": "sha512-pemlzrSESWbdAloYml3bAJMEfNh1Z7EduzqPKprCH5S341frlpYnUEW0H72dLxa6IsYr+mPno20GiSm+h9dEdQ==",
-            "dev": true,
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@babel/code-frame": "^7.10.4",
                 "@babel/runtime": "^7.12.5",
@@ -4242,7 +4245,6 @@
             "version": "4.3.0",
             "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
             "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-            "dev": true,
             "license": "MIT",
             "dependencies": {
                 "color-convert": "^2.0.1"
@@ -4258,7 +4260,6 @@
             "version": "4.1.2",
             "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
             "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-            "dev": true,
             "license": "MIT",
             "dependencies": {
                 "ansi-styles": "^4.1.0",
@@ -4275,7 +4276,6 @@
             "version": "2.0.1",
             "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
             "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-            "dev": true,
             "license": "MIT",
             "dependencies": {
                 "color-name": "~1.1.4"
@@ -4288,14 +4288,12 @@
             "version": "1.1.4",
             "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
             "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-            "dev": true,
             "license": "MIT"
         },
         "node_modules/@testing-library/dom/node_modules/has-flag": {
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
             "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-            "dev": true,
             "license": "MIT",
             "engines": {
                 "node": ">=8"
@@ -4305,7 +4303,6 @@
             "version": "7.2.0",
             "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
             "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-            "dev": true,
             "license": "MIT",
             "dependencies": {
                 "has-flag": "^4.0.0"
@@ -4470,35 +4467,34 @@
             "version": "1.0.11",
             "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.11.tgz",
             "integrity": "sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/@tsconfig/node12": {
             "version": "1.0.11",
             "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
             "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/@tsconfig/node14": {
             "version": "1.0.3",
             "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
             "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/@tsconfig/node16": {
             "version": "1.0.4",
             "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz",
             "integrity": "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/@types/aria-query": {
             "version": "5.0.4",
             "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
             "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
-            "dev": true,
             "license": "MIT"
         },
         "node_modules/@types/babel__core": {
@@ -4728,7 +4724,8 @@
             "version": "16.18.105",
             "resolved": "https://registry.npmjs.org/@types/node/-/node-16.18.105.tgz",
             "integrity": "sha512-w2d0Z9yMk07uH3+Cx0N8lqFyi3yjXZxlbYappPj+AsOlT02OyxyiuNoNHdGt6EuiSm8Wtgp2YV7vWg+GMFrvFA==",
-            "license": "MIT"
+            "license": "MIT",
+            "peer": true
         },
         "node_modules/@types/node-forge": {
             "version": "1.3.11",
@@ -4791,6 +4788,7 @@
             "integrity": "sha512-EhwApuTmMBmXuFOikhQLIBUn6uFg81SwLMOAUgodJF14SOBOCMdU04gDoYi0WOJJHD144TL32z4yDqCW3dnkQg==",
             "dev": true,
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@types/react": "*"
             }
@@ -4911,7 +4909,7 @@
             "version": "17.0.33",
             "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz",
             "integrity": "sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "@types/yargs-parser": "*"
@@ -5116,6 +5114,7 @@
             "integrity": "sha512-j3Di+o0lHgPrb7FxL3fdEy6LJ/j2NE8u+AP/5cQ9SKb+JLH6V6UHDqJ+e0hXBkHP1wn1YDFjYCS9LBQsZDlDEg==",
             "dev": true,
             "license": "BSD-2-Clause",
+            "peer": true,
             "dependencies": {
                 "@typescript-eslint/scope-manager": "8.2.0",
                 "@typescript-eslint/types": "8.2.0",
@@ -5468,6 +5467,7 @@
             "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz",
             "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==",
             "license": "MIT",
+            "peer": true,
             "bin": {
                 "acorn": "bin/acorn"
             },
@@ -5508,7 +5508,7 @@
             "version": "8.3.3",
             "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.3.tgz",
             "integrity": "sha512-MxXdReSRhGO7VlFe1bRG/oI7/mdLV9B9JJT0N8vZOhF7gFRR5l3M8W9G8JxmKV+JC5mGqJ0QvqfSOLsCPa4nUw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "acorn": "^8.11.0"
@@ -5569,6 +5569,7 @@
             "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
             "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "fast-deep-equal": "^3.1.1",
                 "fast-json-stable-stringify": "^2.0.0",
@@ -6556,6 +6557,7 @@
                 }
             ],
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "caniuse-lite": "^1.0.30001646",
                 "electron-to-chromium": "^1.5.4",
@@ -7210,7 +7212,7 @@
             "version": "1.1.1",
             "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
             "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/cross-spawn": {
@@ -7947,7 +7949,7 @@
             "version": "4.0.2",
             "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
             "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
-            "dev": true,
+            "devOptional": true,
             "license": "BSD-3-Clause",
             "engines": {
                 "node": ">=0.3.1"
@@ -8499,6 +8501,7 @@
             "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.0.tgz",
             "integrity": "sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@eslint-community/eslint-utils": "^4.2.0",
                 "@eslint-community/regexpp": "^4.6.1",
@@ -8555,6 +8558,7 @@
             "integrity": "sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==",
             "dev": true,
             "license": "MIT",
+            "peer": true,
             "bin": {
                 "eslint-config-prettier": "bin/cli.js"
             },
@@ -8595,6 +8599,7 @@
             "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz",
             "integrity": "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@eslint-community/regexpp": "^4.4.0",
                 "@typescript-eslint/scope-manager": "5.62.0",
@@ -8629,6 +8634,7 @@
             "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.62.0.tgz",
             "integrity": "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA==",
             "license": "BSD-2-Clause",
+            "peer": true,
             "dependencies": {
                 "@typescript-eslint/scope-manager": "5.62.0",
                 "@typescript-eslint/types": "5.62.0",
@@ -12248,6 +12254,7 @@
             "integrity": "sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==",
             "dev": true,
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@jest/core": "^29.7.0",
                 "@jest/types": "^29.6.3",
@@ -13021,7 +13028,7 @@
             "version": "29.6.3",
             "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.6.3.tgz",
             "integrity": "sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
@@ -13031,7 +13038,7 @@
             "version": "29.7.0",
             "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-29.7.0.tgz",
             "integrity": "sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "@jest/types": "^29.6.3",
@@ -13949,7 +13956,7 @@
             "version": "29.6.3",
             "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-29.6.3.tgz",
             "integrity": "sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
@@ -13959,7 +13966,7 @@
             "version": "29.7.0",
             "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-29.7.0.tgz",
             "integrity": "sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "chalk": "^4.0.0",
@@ -13994,7 +14001,7 @@
             "version": "4.3.0",
             "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
             "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "color-convert": "^2.0.1"
@@ -14010,7 +14017,7 @@
             "version": "4.1.2",
             "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
             "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "ansi-styles": "^4.1.0",
@@ -14027,7 +14034,7 @@
             "version": "2.0.1",
             "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
             "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "color-name": "~1.1.4"
@@ -14040,14 +14047,14 @@
             "version": "1.1.4",
             "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
             "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/jest-resolve/node_modules/has-flag": {
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
             "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=8"
@@ -14057,7 +14064,7 @@
             "version": "1.22.8",
             "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.8.tgz",
             "integrity": "sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "is-core-module": "^2.13.0",
@@ -14075,7 +14082,7 @@
             "version": "7.2.0",
             "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
             "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "has-flag": "^4.0.0"
@@ -14518,7 +14525,7 @@
             "version": "29.7.0",
             "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.7.0.tgz",
             "integrity": "sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "@jest/types": "^29.6.3",
@@ -14536,7 +14543,7 @@
             "version": "4.3.0",
             "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
             "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "color-convert": "^2.0.1"
@@ -14552,7 +14559,7 @@
             "version": "4.1.2",
             "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
             "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "ansi-styles": "^4.1.0",
@@ -14569,7 +14576,7 @@
             "version": "2.0.1",
             "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
             "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "color-name": "~1.1.4"
@@ -14582,14 +14589,14 @@
             "version": "1.1.4",
             "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
             "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/jest-util/node_modules/has-flag": {
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
             "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=8"
@@ -14599,7 +14606,7 @@
             "version": "7.2.0",
             "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
             "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "has-flag": "^4.0.0"
@@ -14612,7 +14619,7 @@
             "version": "29.7.0",
             "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-29.7.0.tgz",
             "integrity": "sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "@jest/types": "^29.6.3",
@@ -14630,7 +14637,7 @@
             "version": "4.3.0",
             "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
             "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "color-convert": "^2.0.1"
@@ -14646,7 +14653,7 @@
             "version": "6.3.0",
             "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
             "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=10"
@@ -14659,7 +14666,7 @@
             "version": "4.1.2",
             "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
             "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "ansi-styles": "^4.1.0",
@@ -14676,7 +14683,7 @@
             "version": "2.0.1",
             "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
             "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "color-name": "~1.1.4"
@@ -14689,14 +14696,14 @@
             "version": "1.1.4",
             "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
             "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/jest-validate/node_modules/has-flag": {
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
             "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=8"
@@ -14706,7 +14713,7 @@
             "version": "29.7.0",
             "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz",
             "integrity": "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "@jest/schemas": "^29.6.3",
@@ -14721,7 +14728,7 @@
             "version": "5.2.0",
             "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
             "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=10"
@@ -14734,14 +14741,14 @@
             "version": "18.3.1",
             "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
             "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/jest-validate/node_modules/supports-color": {
             "version": "7.2.0",
             "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
             "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "has-flag": "^4.0.0"
@@ -14850,7 +14857,7 @@
             "version": "29.7.0",
             "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-29.7.0.tgz",
             "integrity": "sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "@types/node": "*",
@@ -14866,7 +14873,7 @@
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
             "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=8"
@@ -14876,7 +14883,7 @@
             "version": "8.1.1",
             "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
             "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "has-flag": "^4.0.0"
@@ -15368,7 +15375,6 @@
             "version": "1.5.0",
             "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
             "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
-            "dev": true,
             "license": "MIT",
             "bin": {
                 "lz-string": "bin/bin.js"
@@ -15402,7 +15408,7 @@
             "version": "1.3.6",
             "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
             "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
-            "dev": true,
+            "devOptional": true,
             "license": "ISC"
         },
         "node_modules/makeerror": {
@@ -16444,6 +16450,7 @@
                 }
             ],
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "nanoid": "^3.3.7",
                 "picocolors": "^1.0.1",
@@ -17650,6 +17657,7 @@
             "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
             "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "cssesc": "^3.0.0",
                 "util-deprecate": "^1.0.2"
@@ -17759,6 +17767,7 @@
             "integrity": "sha512-i2tDNA0O5IrMO757lfrdQZCc2jPNDVntV0m/+4whiDfWaTKfMNgR7Qz0NAeGz/nRqF4m5/6CLzbP4/liHt12Ew==",
             "dev": true,
             "license": "MIT",
+            "peer": true,
             "bin": {
                 "prettier": "bin/prettier.cjs"
             },
@@ -18290,6 +18299,7 @@
             "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
             "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "loose-envify": "^1.1.0"
             },
@@ -18481,6 +18491,7 @@
             "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
             "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "loose-envify": "^1.1.0",
                 "scheduler": "^0.23.2"
@@ -18512,6 +18523,7 @@
             "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.11.0.tgz",
             "integrity": "sha512-F27qZr8uUqwhWZboondsPx8tnC3Ct3SxZA3V5WyEvujRyyNv0VYPhoBg1gZ8/MV5tubQp76Trw8lTv9hzRBa+A==",
             "license": "MIT",
+            "peer": true,
             "engines": {
                 "node": ">=0.10.0"
             }
@@ -19225,6 +19237,7 @@
             "resolved": "https://registry.npmjs.org/jest/-/jest-27.5.1.tgz",
             "integrity": "sha512-Yn0mADZB89zTtjkPJEXwrac3LHudkQMR+Paqa8uxJHCBr9agxztUifWCyiYrjhMPBoUVBjyny0I7XH6ozDr7QQ==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@jest/core": "^27.5.1",
                 "import-local": "^3.0.2",
@@ -20668,7 +20681,7 @@
             "version": "2.0.2",
             "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.2.tgz",
             "integrity": "sha512-X2UW6Nw3n/aMgDVy+0rSqgHlv39WZAlZrXCdnbyEiKm17DSqHX4MmQMaST3FbeWR5FTuRcUwYAziZajji0Y7mg==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=10"
@@ -20714,6 +20727,7 @@
             "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.1.tgz",
             "integrity": "sha512-uKxbd0IhMZOhjAiD5oAFp7BqvkA4Dv47qpOCtaNvng4HBwdbWtdOh8f5nZNuk2rp51PMGk3bzfWu5oayNEuYnw==",
             "license": "MIT",
+            "peer": true,
             "bin": {
                 "rollup": "dist/bin/rollup"
             },
@@ -20964,6 +20978,7 @@
             "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
             "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "fast-deep-equal": "^3.1.3",
                 "fast-uri": "^3.0.1",
@@ -22588,8 +22603,9 @@
             "version": "10.9.2",
             "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
             "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@cspotcode/source-map-support": "^0.8.0",
                 "@tsconfig/node10": "^1.0.7",
@@ -22632,7 +22648,7 @@
             "version": "4.1.3",
             "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
             "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/tsconfig-paths": {
@@ -22721,6 +22737,7 @@
             "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
             "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
             "license": "(MIT OR CC0-1.0)",
+            "peer": true,
             "engines": {
                 "node": ">=10"
             },
@@ -22828,6 +22845,7 @@
             "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
             "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
             "license": "Apache-2.0",
+            "peer": true,
             "bin": {
                 "tsc": "bin/tsc",
                 "tsserver": "bin/tsserver"
@@ -23056,7 +23074,7 @@
             "version": "3.0.1",
             "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
             "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/v8-to-istanbul": {
@@ -23205,6 +23223,7 @@
             "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.93.0.tgz",
             "integrity": "sha512-Y0m5oEY1LRuwly578VqluorkXbvXKh7U3rLoQCEO04M97ScRr44afGVkI0FQFsXzysk5OgFAxjZAb9rsGQVihA==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@types/eslint-scope": "^3.7.3",
                 "@types/estree": "^1.0.5",
@@ -23275,6 +23294,7 @@
             "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.15.2.tgz",
             "integrity": "sha512-0XavAZbNJ5sDrCbkpWL8mia0o5WPOd2YGtxrEiZkBK9FjLppIUK2TgxK6qGD2P3hUXTJNNPVibrerKcx5WkR1g==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@types/bonjour": "^3.5.9",
                 "@types/connect-history-api-fallback": "^1.3.5",
@@ -23665,6 +23685,7 @@
             "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
             "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "fast-deep-equal": "^3.1.3",
                 "fast-uri": "^3.0.1",
@@ -24118,7 +24139,7 @@
             "version": "3.1.1",
             "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
             "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=6"
diff --git a/src/App.css b/src/App.css
index ad32fac073..65788883e5 100644
--- a/src/App.css
+++ b/src/App.css
@@ -15,7 +15,7 @@
 
 .App-header {
     width: 100%;
-    background-color: #282c34;
+    background-color: #28e60f;
     min-height: 40vh;
     display: flex;
     flex-direction: column;
diff --git a/src/App.tsx b/src/App.tsx
index 1f9386865b..35f19b11cf 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,13 +1,51 @@
 import React from "react";
 import "./App.css";
+import { Button, Col, Container, Row } from "react-bootstrap";
+import { CONNREFUSED } from "node:dns";
 
 function App(): React.JSX.Element {
     return (
         <div className="App">
             <header className="App-header">
-                UM COS420 with React Hooks and TypeScript
+                UM COS420 with React Hooks and TypeScript ALSO Hello World
             </header>
-            <p>Gavin Pierce</p>
+            <Container>
+                <Row>
+                    <Col>
+                        <h1>Hello this is a header</h1>
+                        <img src="../public/logo192.png" alt="The Logo" />
+                        <ol>
+                            <li>Hotdogs</li>
+                            <li>Burgers</li>
+                            <li>Fireworks</li>
+                        </ol>
+                        <div
+                            style={{
+                                width: "20px",
+                                height: "10px",
+                                backgroundColor: "red",
+                            }}
+                        ></div>
+                    </Col>
+                    <Col>
+                        <Button
+                            onClick={() => {
+                                console.log("Hello World!");
+                            }}
+                        >
+                            Log Hello World
+                        </Button>
+                        <p>Gavin Pierce</p>
+                        <div
+                            style={{
+                                width: "20px",
+                                height: "10px",
+                                backgroundColor: "red",
+                            }}
+                        ></div>
+                    </Col>
+                </Row>
+            </Container>
         </div>
     );
 }

From b4c0b42bc35eb12a394f8e7e3c4db483c799c76b Mon Sep 17 00:00:00 2001
From: gavinmpierce <157523429+gavinmpierce@users.noreply.github.com>
Date: Tue, 10 Feb 2026 18:10:52 -0500
Subject: [PATCH 41/46] first attempts

---
 src/arrays.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/arrays.ts b/src/arrays.ts
index 4a2ffe8e5b..35d84f0ffa 100644
--- a/src/arrays.ts
+++ b/src/arrays.ts
@@ -5,7 +5,10 @@
  * the number twice.
  */
 export function bookEndList(numbers: number[]): number[] {
-    return numbers;
+    if (numbers.length == 1) {
+        return [numbers[0], numbers[0]];
+    }
+    return [numbers[0], numbers[numbers.length - 1]];
 }
 
 /**
@@ -13,6 +16,7 @@ export function bookEndList(numbers: number[]): number[] {
  * number has been tripled (multiplied by 3).
  */
 export function tripleNumbers(numbers: number[]): number[] {
+    numbers = numbers.map((price: number): number => 3 * price);
     return numbers;
 }
 
@@ -21,6 +25,7 @@ export function tripleNumbers(numbers: number[]): number[] {
  * the number cannot be parsed as an integer, convert it to 0 instead.
  */
 export function stringsToIntegers(numbers: string[]): number[] {
+    numbers = numbers.map((temp: string): temp => (temp = number));
     return [];
 }
 

From cf44548d1c5f407b07d69316a3796d5a87d7952d Mon Sep 17 00:00:00 2001
From: gavinmpierce <157523429+gavinmpierce@users.noreply.github.com>
Date: Tue, 17 Feb 2026 16:31:34 -0500
Subject: [PATCH 42/46] complete test

---
 src/arrays.ts | 69 +++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 62 insertions(+), 7 deletions(-)

diff --git a/src/arrays.ts b/src/arrays.ts
index 35d84f0ffa..0e4c37fad1 100644
--- a/src/arrays.ts
+++ b/src/arrays.ts
@@ -8,6 +8,9 @@ export function bookEndList(numbers: number[]): number[] {
     if (numbers.length == 1) {
         return [numbers[0], numbers[0]];
     }
+    if (numbers.length == 0) {
+        return [];
+    }
     return [numbers[0], numbers[numbers.length - 1]];
 }
 
@@ -25,8 +28,8 @@ export function tripleNumbers(numbers: number[]): number[] {
  * the number cannot be parsed as an integer, convert it to 0 instead.
  */
 export function stringsToIntegers(numbers: string[]): number[] {
-    numbers = numbers.map((temp: string): temp => (temp = number));
-    return [];
+    const integers = numbers.map((num: string): number => parseInt(num) || 0);
+    return integers;
 }
 
 /**
@@ -37,7 +40,11 @@ export function stringsToIntegers(numbers: string[]): number[] {
  */
 // Remember, you can write functions as lambdas too! They work exactly the same.
 export const removeDollars = (amounts: string[]): number[] => {
-    return [];
+    const temp = amounts.map(
+        (num: string): number =>
+            parseInt(num.startsWith("$") ? num.slice(1) : num) || 0,
+    );
+    return temp;
 };
 
 /**
@@ -46,7 +53,12 @@ export const removeDollars = (amounts: string[]): number[] => {
  * in question marks ("?").
  */
 export const shoutIfExclaiming = (messages: string[]): string[] => {
-    return [];
+    const temp = messages.filter((mes: string): boolean => !mes.endsWith("?"));
+    const tempAgain = temp.map((mes: string): string =>
+        mes.endsWith("!") ? mes.toUpperCase() : mes,
+    );
+    // i need to thikn of better variable names clearly
+    return tempAgain;
 };
 
 /**
@@ -54,7 +66,8 @@ export const shoutIfExclaiming = (messages: string[]): string[] => {
  * 4 letters long.
  */
 export function countShortWords(words: string[]): number {
-    return 0;
+    const temp = words.filter((mes: string): boolean => mes.length < 4);
+    return temp.length;
 }
 
 /**
@@ -63,6 +76,13 @@ export function countShortWords(words: string[]): number {
  * then return true.
  */
 export function allRGB(colors: string[]): boolean {
+    const temp = colors.filter(
+        (mes: string): boolean =>
+            mes === "red" || mes === "blue" || mes === "green",
+    );
+    if (colors.length == temp.length) {
+        return true;
+    }
     return false;
 }
 
@@ -74,7 +94,15 @@ export function allRGB(colors: string[]): boolean {
  * And the array [] would become "0=0".
  */
 export function makeMath(addends: number[]): string {
-    return "";
+    const total = addends.reduce(
+        (currentTotal: number, num: number) => currentTotal + num,
+        0,
+    );
+    if (addends.length === 0) {
+        return "0=0";
+    }
+    const temp = `${total}=${addends.join("+")}`;
+    return temp;
 }
 
 /**
@@ -86,6 +114,33 @@ export function makeMath(addends: number[]): string {
  * For instance, the array [1, 9, -5, 7] would become [1, 9, -5, 10, 7]
  * And the array [1, 9, 7] would become [1, 9, 7, 17]
  */
+// Used Ai for the negatives part of the question
 export function injectPositive(values: number[]): number[] {
-    return [];
+    const result = [...values];
+
+    const negatives = result.filter((num: number): boolean => num < 0);
+
+    if (negatives.length > 0) {
+        const firstNegative = negatives[0];
+        const index = result.indexOf(firstNegative);
+
+        const sumBefore = result
+            .slice(0, index)
+            .reduce(
+                (currentTotal: number, num: number) => currentTotal + num,
+                0,
+            );
+
+        result.splice(index + 1, 0, sumBefore);
+        return result;
+    }
+
+    // No negatives → append total sum
+    const total = result.reduce(
+        (currentTotal: number, num: number) => currentTotal + num,
+        0,
+    );
+
+    result.splice(result.length, 0, total);
+    return result;
 }

From cd1693342301f54851dffaf76de70d9dcc487280 Mon Sep 17 00:00:00 2001
From: gavinmpierce <157523429+gavinmpierce@users.noreply.github.com>
Date: Tue, 17 Feb 2026 21:30:37 -0500
Subject: [PATCH 43/46] answers so far

---
 src/objects.ts | 63 ++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 53 insertions(+), 10 deletions(-)

diff --git a/src/objects.ts b/src/objects.ts
index 3fd2072e5e..c8b605cc43 100644
--- a/src/objects.ts
+++ b/src/objects.ts
@@ -8,9 +8,18 @@ import { Question, QuestionType } from "./interfaces/question";
 export function makeBlankQuestion(
     id: number,
     name: string,
-    type: QuestionType
+    type: QuestionType,
 ): Question {
-    return {};
+    return {
+        id,
+        name,
+        type,
+        body: "",
+        expected: "",
+        options: [],
+        points: 1,
+        published: false,
+    };
 }
 
 /**
@@ -21,7 +30,9 @@ export function makeBlankQuestion(
  * HINT: Look up the `trim` and `toLowerCase` functions.
  */
 export function isCorrect(question: Question, answer: string): boolean {
-    return false;
+    const checkCorrect =
+        answer.trim().toLowerCase() === question.expected.trim().toLowerCase();
+    return checkCorrect;
 }
 
 /**
@@ -31,7 +42,12 @@ export function isCorrect(question: Question, answer: string): boolean {
  * be exactly one of the options.
  */
 export function isValid(question: Question, answer: string): boolean {
-    return false;
+    if (question.type === "short_answer_question") {
+        return true;
+    }
+    // if it is a multiple choice
+    const checkAnswer = question.options.includes(answer);
+    return checkAnswer;
 }
 
 /**
@@ -41,7 +57,8 @@ export function isValid(question: Question, answer: string): boolean {
  * name "My First Question" would become "9: My First Q".
  */
 export function toShortForm(question: Question): string {
-    return "";
+    const shortForm = `${question.id}: ${question.name.substring(0, 10)}`;
+    return shortForm;
 }
 
 /**
@@ -62,7 +79,15 @@ export function toShortForm(question: Question): string {
  * Check the unit tests for more examples of what this looks like!
  */
 export function toMarkdown(question: Question): string {
-    return "";
+    if (question.type !== "multiple_choice_question") {
+        const formatedShortQ = `# ${question.name}\n${question.body}`;
+        return formatedShortQ;
+    }
+    let formatedMultipleQ = `# ${question.name}\n${question.body}`;
+    for (const option of question.options) {
+        formatedMultipleQ += `\n- ${option}`;
+    }
+    return formatedMultipleQ;
 }
 
 /**
@@ -70,6 +95,7 @@ export function toMarkdown(question: Question): string {
  * `newName`.
  */
 export function renameQuestion(question: Question, newName: string): Question {
+    question.name = newName;
     return question;
 }
 
@@ -79,6 +105,7 @@ export function renameQuestion(question: Question, newName: string): Question {
  * published; if it was published, now it should be not published.
  */
 export function publishQuestion(question: Question): Question {
+    question.published = !question.published;
     return question;
 }
 
@@ -89,7 +116,13 @@ export function publishQuestion(question: Question): Question {
  * The `published` field should be reset to false.
  */
 export function duplicateQuestion(id: number, oldQuestion: Question): Question {
-    return oldQuestion;
+    let newQuestion: Question = {
+        ...oldQuestion,
+        id,
+        name: `Copy of ${oldQuestion.name}`,
+        published: false,
+    };
+    return newQuestion;
 }
 
 /**
@@ -100,7 +133,11 @@ export function duplicateQuestion(id: number, oldQuestion: Question): Question {
  * Check out the subsection about "Nested Fields" for more information.
  */
 export function addOption(question: Question, newOption: string): Question {
-    return question;
+    let updatedQuestion: Question = {
+        ...question,
+        options: [...question.options, newOption],
+    };
+    return updatedQuestion;
 }
 
 /**
@@ -115,7 +152,13 @@ export function mergeQuestion(
     id: number,
     name: string,
     contentQuestion: Question,
-    { points }: { points: number }
+    { points }: { points: number },
 ): Question {
-    return contentQuestion;
+    return {
+        ...contentQuestion,
+        id,
+        name,
+        points,
+        published: false,
+    };
 }

From b9a8ba9fb9ff8ee88ee95c3839be627803cd603d Mon Sep 17 00:00:00 2001
From: gavinmpierce <157523429+gavinmpierce@users.noreply.github.com>
Date: Wed, 18 Feb 2026 19:59:10 -0500
Subject: [PATCH 44/46] changes that work

---
 src/objects.ts | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/objects.ts b/src/objects.ts
index c8b605cc43..50918ce7a3 100644
--- a/src/objects.ts
+++ b/src/objects.ts
@@ -95,8 +95,10 @@ export function toMarkdown(question: Question): string {
  * `newName`.
  */
 export function renameQuestion(question: Question, newName: string): Question {
-    question.name = newName;
-    return question;
+    return {
+        ...question,
+        name: newName,
+    };
 }
 
 /**
@@ -105,8 +107,10 @@ export function renameQuestion(question: Question, newName: string): Question {
  * published; if it was published, now it should be not published.
  */
 export function publishQuestion(question: Question): Question {
-    question.published = !question.published;
-    return question;
+    return {
+        ...question,
+        published: !question.published,
+    };
 }
 
 /**

From 616ab8dadb42fc7801b4470375fc003e25b13b79 Mon Sep 17 00:00:00 2001
From: gavinmpierce <157523429+gavinmpierce@users.noreply.github.com>
Date: Sun, 22 Feb 2026 18:54:01 -0500
Subject: [PATCH 45/46] questions so far

---
 src/nested.ts | 58 ++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 43 insertions(+), 15 deletions(-)

diff --git a/src/nested.ts b/src/nested.ts
index 78390a31a7..3d1bc37eac 100644
--- a/src/nested.ts
+++ b/src/nested.ts
@@ -1,12 +1,14 @@
 import { Answer } from "./interfaces/answer";
 import { Question, QuestionType } from "./interfaces/question";
+import { makeBlankQuestion } from "./objects";
 
 /**
  * Consumes an array of questions and returns a new array with only the questions
  * that are `published`.
  */
 export function getPublishedQuestions(questions: Question[]): Question[] {
-    return [];
+    const newQuestions = questions.filter((question) => question.published);
+    return newQuestions;
 }
 
 /**
@@ -15,7 +17,13 @@ export function getPublishedQuestions(questions: Question[]): Question[] {
  * `expected`, and an empty array for its `options`.
  */
 export function getNonEmptyQuestions(questions: Question[]): Question[] {
-    return [];
+    const nonEmpty = questions.filter(
+        (question) =>
+            question.body.trim() !== "" ||
+            question.expected.trim() !== "" ||
+            question.options.length > 0,
+    );
+    return nonEmpty;
 }
 
 /***
@@ -24,8 +32,12 @@ export function getNonEmptyQuestions(questions: Question[]): Question[] {
  */
 export function findQuestion(
     questions: Question[],
-    id: number
+    id: number,
 ): Question | null {
+    const found = questions.find((question) => question.id === id);
+    if (found) {
+        return found;
+    }
     return null;
 }
 
@@ -35,7 +47,8 @@ export function findQuestion(
  * Hint: use filter
  */
 export function removeQuestion(questions: Question[], id: number): Question[] {
-    return [];
+    const newArray = questions.filter((question) => id !== question.id);
+    return newArray;
 }
 
 /***
@@ -44,7 +57,8 @@ export function removeQuestion(questions: Question[], id: number): Question[] {
  * Do not modify the input array.
  */
 export function getNames(questions: Question[]): string[] {
-    return [];
+    const newArray = questions.map((question) => question.name);
+    return newArray;
 }
 
 /**
@@ -53,7 +67,13 @@ export function getNames(questions: Question[]): string[] {
  * making the `text` an empty string, and using false for both `submitted` and `correct`.
  */
 export function makeAnswers(questions: Question[]): Answer[] {
-    return [];
+    const newArray = questions.map((question) => ({
+        questionId: question.id,
+        text: "",
+        submitted: false,
+        correct: false,
+    }));
+    return newArray;
 }
 
 /***
@@ -62,7 +82,11 @@ export function makeAnswers(questions: Question[]): Answer[] {
  * Hint: as usual, do not modify the input questions array
  */
 export function publishAll(questions: Question[]): Question[] {
-    return [];
+    const newArray = questions.map((question) => ({
+        ...question,
+        published: true,
+    }));
+    return newArray;
 }
 
 /***
@@ -75,24 +99,28 @@ export function addNewQuestion(
     questions: Question[],
     id: number,
     name: string,
-    type: QuestionType
+    type: QuestionType,
 ): Question[] {
-    return [];
+    const newArray = makeBlankQuestion(id, name, type);
+    return [...questions, newArray];
 }
 
 /***
  * Consumes an array of Questions and produces a new array of Questions, where all
  * the Questions are the same EXCEPT for the one with the given `targetId`. That
  * Question should be the same EXCEPT that its name should now be `newName`.
- * Hint: as usual, do not modify the input questions array, 
+ * Hint: as usual, do not modify the input questions array,
  *       to make a new copy of a question with some changes, use the ... operator
  */
 export function renameQuestionById(
     questions: Question[],
     targetId: number,
-    newName: string
+    newName: string,
 ): Question[] {
-    return [];
+    const newArray = questions.map((question) =>
+        question.id === targetId ? { ...question, name: newName } : question,
+    );
+    return newArray;
 }
 
 /**
@@ -104,14 +132,14 @@ export function renameQuestionById(
  *
  * Remember, if a function starts getting too complicated, think about how a helper function
  * can make it simpler! Break down complicated tasks into little pieces.
- * 
+ *
  * Hint: you need to use the ... operator for both the question and the options array
  */
 export function editOption(
     questions: Question[],
     targetId: number,
     targetOptionIndex: number,
-    newOption: string
+    newOption: string,
 ): Question[] {
     return [];
-}
\ No newline at end of file
+}

From 8fddf394766c971e9dc3e9c238de9bb686906e72 Mon Sep 17 00:00:00 2001
From: gavinmpierce <157523429+gavinmpierce@users.noreply.github.com>
Date: Wed, 25 Feb 2026 14:42:28 -0500
Subject: [PATCH 46/46] finished

---
 src/nested.ts | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/nested.ts b/src/nested.ts
index 3d1bc37eac..b5b225b790 100644
--- a/src/nested.ts
+++ b/src/nested.ts
@@ -141,5 +141,17 @@ export function editOption(
     targetOptionIndex: number,
     newOption: string,
 ): Question[] {
-    return [];
+    const newArray = questions.map((question) => {
+        if (question.id === targetId) {
+            const newOptions = [...question.options];
+            if (targetOptionIndex === -1) {
+                newOptions.push(newOption);
+            } else {
+                newOptions[targetOptionIndex] = newOption;
+            }
+            return { ...question, options: newOptions };
+        }
+        return question;
+    });
+    return newArray;
 }