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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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 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 10/21] 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 11/21] 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 12/21] 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 13/21] 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 14/21] 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 15/21] 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 16/21] 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 17/21] 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 6779e7266ed20f59671f4b656f1d0fb7fd2094e8 Mon Sep 17 00:00:00 2001
From: ARIVATTRAL RAJKUMAR <arir@udel.edu>
Date: Fri, 6 Feb 2026 14:17:46 -0500
Subject: [PATCH 18/21] Added name to App

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

diff --git a/src/App.tsx b/src/App.tsx
index b77558eaac..b1f205c03d 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -11,6 +11,7 @@ function App(): React.JSX.Element {
                 Edit <code>src/App.tsx</code> and save. This page will
                 automatically reload.
             </p>
+            <p>Arivattral Rajkumar</p>
         </div>
     );
 }

From e3230359014d805ab94e937825860f9bf41bd4e8 Mon Sep 17 00:00:00 2001
From: Arivattral Rajkumar <arir@udel.edu>
Date: Wed, 11 Feb 2026 18:43:25 -0500
Subject: [PATCH 19/21] Add Hello World text

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

diff --git a/src/App.tsx b/src/App.tsx
index b1f205c03d..14ba523f7c 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -11,6 +11,7 @@ function App(): React.JSX.Element {
                 Edit <code>src/App.tsx</code> and save. This page will
                 automatically reload.
             </p>
+            <p>Hello World</p>
             <p>Arivattral Rajkumar</p>
         </div>
     );

From 7aa2a8c46f41c605e3133274fa3f47f50d4cf8ee Mon Sep 17 00:00:00 2001
From: Arivattral Rajkumar <arir@udel.edu>
Date: Sun, 22 Feb 2026 19:40:16 -0500
Subject: [PATCH 20/21] finished all the code for this task

---
 src/arrays.ts | 48 +++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 39 insertions(+), 9 deletions(-)

diff --git a/src/arrays.ts b/src/arrays.ts
index 4a2ffe8e5b..d54f6902e9 100644
--- a/src/arrays.ts
+++ b/src/arrays.ts
@@ -5,7 +5,13 @@
  * the number twice.
  */
 export function bookEndList(numbers: number[]): number[] {
-    return numbers;
+    if (numbers.length === 0) {
+        return [];
+    } else if (numbers.length === 1) {
+        return [numbers[0], numbers[0]];
+    } else {
+        return [numbers[0], numbers[numbers.length - 1]];
+    }
 }
 
 /**
@@ -13,7 +19,7 @@ export function bookEndList(numbers: number[]): number[] {
  * number has been tripled (multiplied by 3).
  */
 export function tripleNumbers(numbers: number[]): number[] {
-    return numbers;
+    return numbers.map((num: number): number => num * 3);
 }
 
 /**
@@ -21,7 +27,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[] {
-    return [];
+    return numbers.map((num: string): number => parseInt(num) || 0);
 }
 
 /**
@@ -32,7 +38,9 @@ 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 [];
+    return amounts.map(
+        (amount: string): number => parseInt(amount.replace("$", "")) || 0,
+    );
 };
 
 /**
@@ -41,7 +49,11 @@ export const removeDollars = (amounts: string[]): number[] => {
  * in question marks ("?").
  */
 export const shoutIfExclaiming = (messages: string[]): string[] => {
-    return [];
+    return messages
+        .filter((msg: string): boolean => !msg.endsWith("?"))
+        .map((msg: string): string =>
+            msg.endsWith("!") ? msg.toUpperCase() : msg,
+        );
 };
 
 /**
@@ -49,7 +61,7 @@ export const shoutIfExclaiming = (messages: string[]): string[] => {
  * 4 letters long.
  */
 export function countShortWords(words: string[]): number {
-    return 0;
+    return words.filter((word: string): boolean => word.length < 4).length;
 }
 
 /**
@@ -58,7 +70,9 @@ export function countShortWords(words: string[]): number {
  * then return true.
  */
 export function allRGB(colors: string[]): boolean {
-    return false;
+    return colors.every(
+        (c: string): boolean => c === "red" || c === "blue" || c === "green",
+    );
 }
 
 /**
@@ -69,7 +83,12 @@ export function allRGB(colors: string[]): boolean {
  * And the array [] would become "0=0".
  */
 export function makeMath(addends: number[]): string {
-    return "";
+    const sum = addends.reduce(
+        (total: number, n: number): number => total + n,
+        0,
+    );
+    const rightSide = addends.length === 0 ? "0" : addends.join("+");
+    return `${sum}=${rightSide}`;
 }
 
 /**
@@ -82,5 +101,16 @@ export function makeMath(addends: number[]): string {
  * And the array [1, 9, 7] would become [1, 9, 7, 17]
  */
 export function injectPositive(values: number[]): number[] {
-    return [];
+    const i = values.findIndex((n: number): boolean => n < 0);
+    const sum = values
+        .slice(0, i === -1 ? values.length : i)
+        .reduce((total: number, n: number): number => total + n, 0);
+
+    if (i === -1) {
+        return [...values, sum];
+    } else {
+        const copy = [...values];
+        copy.splice(i + 1, 0, sum);
+        return copy;
+    }
 }

From 3789c8ad62199ee2c5db211dde758bd367dd4a31 Mon Sep 17 00:00:00 2001
From: Arivattral Rajkumar <arir@udel.edu>
Date: Mon, 2 Mar 2026 14:08:32 -0500
Subject: [PATCH 21/21] Completed objects task

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

diff --git a/src/objects.ts b/src/objects.ts
index 3fd2072e5e..0810e2c61a 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: id,
+        name: name,
+        type: 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;
+    return (
+        answer.trim().toLowerCase() === question.expected.trim().toLowerCase()
+    );
 }
 
 /**
@@ -31,7 +42,11 @@ 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;
+    } else {
+        return question.options.includes(answer);
+    }
 }
 
 /**
@@ -41,7 +56,7 @@ 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 "";
+    return `${question.id}: ${question.name.slice(0, 10)}`;
 }
 
 /**
@@ -62,7 +77,17 @@ 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 "";
+    const headerLine = `# ${question.name}`;
+    const bodyLine = question.body;
+
+    if (question.type === "multiple_choice_question") {
+        const optionLines = question.options.map(
+            (option: string): string => `- ${option}`,
+        );
+        return [headerLine, bodyLine, ...optionLines].join("\n");
+    } else {
+        return [headerLine, bodyLine].join("\n");
+    }
 }
 
 /**
@@ -70,7 +95,7 @@ export function toMarkdown(question: Question): string {
  * `newName`.
  */
 export function renameQuestion(question: Question, newName: string): Question {
-    return question;
+    return { ...question, name: newName };
 }
 
 /**
@@ -79,7 +104,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 {
-    return question;
+    return { ...question, published: !question.published };
 }
 
 /**
@@ -89,7 +114,16 @@ export function publishQuestion(question: Question): Question {
  * The `published` field should be reset to false.
  */
 export function duplicateQuestion(id: number, oldQuestion: Question): Question {
-    return oldQuestion;
+    return {
+        id: id,
+        name: `Copy of ${oldQuestion.name}`,
+        type: oldQuestion.type,
+        body: oldQuestion.body,
+        expected: oldQuestion.expected,
+        options: [...oldQuestion.options],
+        points: oldQuestion.points,
+        published: false,
+    };
 }
 
 /**
@@ -100,7 +134,7 @@ 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;
+    return { ...question, options: [...question.options, newOption] };
 }
 
 /**
@@ -115,7 +149,14 @@ export function mergeQuestion(
     id: number,
     name: string,
     contentQuestion: Question,
-    { points }: { points: number }
+    { points }: { points: number },
 ): Question {
-    return contentQuestion;
+    return {
+        ...contentQuestion,
+        id: id,
+        name: name,
+        points: points,
+        published: false,
+        options: [...contentQuestion.options],
+    };
 }