Refactor the child tests in positionTest.js

Author: Beau Shinkle

test/positionTest.js

@@ -111,9 +111,59 @@ describe("Position", async () => {
   })
 
   describe("child", async () => {
-    it("Returns the child address", async () => {
-      const result = await positionInstance.child(parentPosition, childPosition)
-      expect(result).to.be.equal(fullPosition)
+    it("Returns the position of the child given the position and slot of the parent", async () => {
+      // Sample Cases
+      //
+      // The first position gets the first slot in the first parent, the
+      // second gets the second slot in the first parent, and so on, until
+      // the 9th, which gets the first slot in the second parent. Working
+      // backwards, that means that if we know the parent's position and
+      // child's slot, the child's position is `parentPosition * 8 + slot`
+      const testData = [
+        {
+          position: 24603,
+          slot: 7,
+          child: 196831,
+        },
+        {
+          position: 29871,
+          slot: 0,
+          child: 238968,
+        },
+        {
+          position: 3875,
+          slot: 2,
+          child: 31002,
+        },
+        {
+          position: 202242,
+          slot: 4,
+          child: 1617940,
+        },
+      ]
+      for (let i = 0; i < testData.length; i++) {
+        const test = testData[i]
+        const child = await positionInstance.child(test.position, test.slot)
+        expect(child).to.equal(
+          test.child,
+          `unexpected result for test index ${i}`,
+        )
+      }
+
+      // Generative Testing
+      const numSamples = 100
+      const maxParentIndex = Math.pow(8, 6) // the largest possible parent index
+      for (let i = 0; i < numSamples; i++) {
+        // generate a random position in [0, maxParentIndex)
+        const position = Math.floor(Math.random() * maxParentIndex)
+        const slot = Math.floor(Math.random() * 8) // slots range from 0 to 7
+        const child = await positionInstance.child(position, slot)
+        const expectation = position * 8 + slot
+        expect(child).to.equal(
+          expectation,
+          `unexpected result for position ${position}`,
+        )
+      }
     })
   })
 })