Add more structure tests.

Author: K Hudson

package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structures-ts",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
   "main": "index.js",
   "type": "module",

src/LinkedList.ts

@@ -0,0 +1 @@
+export default class LinkedList {}

src/Queue.ts

@@ -0,0 +1 @@
+export default class Queue {}

tests/LinkedList.test.ts

@@ -0,0 +1,54 @@
+import LinkedList from "../src/LinkedList";
+import Node from "../src/Node";
+
+
+test("Smoke test ...", () => {
+    expect(true).toEqual(true);
+});
+
+describe("LinkedList", () => {
+    let linkedList: LinkedList;
+
+    beforeEach(() => {
+        linkedList = new LinkedList();
+    })
+
+    test("should be empty on instantiation", () => {
+        expect(linkedList.isEmpty()).toBeTruthy()
+    });
+
+    test("should return head node", () => {
+        let node = new Node();
+        linkedList.addNode(node)
+        expect(linkedList.head()).toBeTruthy()
+    });
+
+    test("should return total count of nodes", () => {
+        let node = new Node();
+        linkedList.addNode(node)
+        expect(linkedList.count()).toEqual(1)
+    });
+
+    test("should find a node and return it", () => {
+        let node = new Node();
+        let node2 = new Node();
+        linkedList.addNode(node)
+        linkedList.addNode(node2)
+        let result = linkedList.find(node);
+        expect(result).toEqual(node);
+    });
+
+    test("should remove a node", () => {
+        let aNode = new Node();
+        let bNode = new Node();
+        let cNode = new Node();
+        let dNode = new Node();
+        linkedList.addNode(aNode)
+        linkedList.addNode(bNode)
+        linkedList.addNode(cNode)
+        linkedList.addNode(dNode)
+        linkedList.remove(cNode);
+        expect(linkedList.count()).toEqual(3);
+        expect(linkedList.bNode.next()).toEqual(dNode);
+    });
+})

tests/Queue.test.ts

@@ -0,0 +1,49 @@
+import Queue from "../src/Queue";
+import Node from "../src/Node";
+
+test("Smoke test ...", () => {
+    expect(true).toEqual(true);
+});
+
+describe("Queue", () => {
+    let queue: Queue;
+
+    beforeEach(() => {
+        queue = new Queue();
+    });
+
+    test("should be empty", () => {
+        expect(queue.isEmpty()).toEqual(true);
+    });
+
+    test("enqueue() should add a node", () => {
+        let node = new Node();
+        queue.enqueue(node);
+        expect(queue.isEmpty()).toEqual(false);
+    });
+
+    test("should return length", () => {
+        let node = new Node();
+        queue.enqueue(node);
+        expect(queue.length()).toEqual(1);
+    });
+
+    test("should add many nodes FIFO", () => {
+        let firstNode = new Node();
+        queue.enqueue(firstNode);
+        queue.enqueue(new Node());
+        queue.enqueue(new Node("End"));
+        expect(firstNode).toEqual(queue.front());
+        expect("End").toEqual(queue.rear().value());
+    });
+
+    test("dequeue() should remove a node FIFO", () => {
+        let firstIn = new Node();
+        let secondIn = new Node();
+        queue.enqueue(firstIn);
+        queue.enqueue(secondIn);
+        let firstOut = queue.dequeue();
+        expect(firstIn).toEqual(firstOut);
+        expect(secondIn).toEqual(queue.front());
+    });
+})