feat: Test running overhaul, switch to Prettier & reformat everything (#1407)

* chore: Switch to Node 20 + Vitest

* chore: migrate to vitest mock functions

* chore: code style (switch to prettier)

* test: re-enable long-running test

Seems the switch to Node 20 and Vitest has vastly improved the code's and / or the test's runtime!

see #1193

* chore: code style

* chore: fix failing tests

* Updated Documentation in README.md

* Update contribution guidelines to state usage of Prettier

* fix: set prettier printWidth back to 80

* chore: apply updated code style automatically

* fix: set prettier line endings to lf again

* chore: apply updated code style automatically

---------

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Co-authored-by: Lars Müller <34514239+appgurueu@users.noreply.github.com>

Cellular-Automata/ConwaysGameOfLife.js

@@ -11,7 +11,7 @@ The Game of Life is a cellular automaton devised by the British mathematician Jo
 /**
  * Generates the next generation for a given state of Conway's Game of Life.
  */
-export function newGeneration (cells) {
+export function newGeneration(cells) {
   const nextGeneration = []
   for (let i = 0; i < cells.length; i++) {
     const nextGenerationRow = []
@@ -20,12 +20,14 @@ export function newGeneration (cells) {
       let neighbourCount = 0
       if (i > 0 && j > 0) neighbourCount += cells[i - 1][j - 1]
       if (i > 0) neighbourCount += cells[i - 1][j]
-      if (i > 0 && j < cells[i].length - 1) neighbourCount += cells[i - 1][j + 1]
+      if (i > 0 && j < cells[i].length - 1)
+        neighbourCount += cells[i - 1][j + 1]
       if (j > 0) neighbourCount += cells[i][j - 1]
       if (j < cells[i].length - 1) neighbourCount += cells[i][j + 1]
       if (i < cells.length - 1 && j > 0) neighbourCount += cells[i + 1][j - 1]
       if (i < cells.length - 1) neighbourCount += cells[i + 1][j]
-      if (i < cells.length - 1 && j < cells[i].length - 1) neighbourCount += cells[i + 1][j + 1]
+      if (i < cells.length - 1 && j < cells[i].length - 1)
+        neighbourCount += cells[i + 1][j + 1]
 
       // Decide whether the cell is alive or dead
       const alive = cells[i][j] === 1

Cellular-Automata/Elementary.js

@@ -64,20 +64,26 @@
  * @param {number} rule The current rule of the Elementary Cellular Automata simulation. Must be an integer between 0 and 255 inclusive
  * @returns {(0 | 1)[]} The next generation according to the inputted rule
  */
-export function getNextElementaryGeneration (generation, rule) {
+export function getNextElementaryGeneration(generation, rule) {
   const NUM_ELEMENTARY_NEIGHBORHOOD_STATES = 8
   const MIN_RULE = 0
   const MAX_RULE = 255
 
   if (!Number.isInteger(rule)) {
-    throw new Error(`Rule must be an integer between the values 0 and 255 (got ${rule})`)
+    throw new Error(
+      `Rule must be an integer between the values 0 and 255 (got ${rule})`
+    )
   }
   if (rule < MIN_RULE || rule > MAX_RULE) {
-    throw new RangeError(`Rule must be an integer between the values 0 and 255 (got ${rule})`)
+    throw new RangeError(
+      `Rule must be an integer between the values 0 and 255 (got ${rule})`
+    )
   }
 
-  const binaryRule = rule.toString(2).padStart(NUM_ELEMENTARY_NEIGHBORHOOD_STATES, '0')
-  const ruleData = binaryRule.split('').map(bit => Number.parseInt(bit)) // note that ruleData[0] represents "all alive" while ruleData[7] represents "all dead"
+  const binaryRule = rule
+    .toString(2)
+    .padStart(NUM_ELEMENTARY_NEIGHBORHOOD_STATES, '0')
+  const ruleData = binaryRule.split('').map((bit) => Number.parseInt(bit)) // note that ruleData[0] represents "all alive" while ruleData[7] represents "all dead"
   const output = new Array(generation.length)
   const LEFT_DEAD = 4 // 100 in binary
   const MIDDLE_DEAD = 2 // 010 in binary

Cellular-Automata/test/ConwaysGameOfLife.test.js

@@ -2,7 +2,16 @@ import { newGeneration } from '../ConwaysGameOfLife'
 
 describe('newGeneration', () => {
   it('should produce the next generation according to the rules', () => {
-    expect(newGeneration([[0, 1, 0], [0, 1, 0], [0, 1, 0]]))
-      .toEqual([[0, 0, 0], [1, 1, 1], [0, 0, 0]])
+    expect(
+      newGeneration([
+        [0, 1, 0],
+        [0, 1, 0],
+        [0, 1, 0]
+      ])
+    ).toEqual([
+      [0, 0, 0],
+      [1, 1, 1],
+      [0, 0, 0]
+    ])
   })
 })

Cellular-Automata/test/Elementary.test.js

@@ -3,91 +3,137 @@ import { getNextElementaryGeneration } from '../Elementary'
 describe('Elementary Cellular Automata', () => {
   describe('Rule Errors', () => {
     it('Correct', () => {
-      expect(() => getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 128)).not.toThrow()
+      expect(() =>
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 128)
+      ).not.toThrow()
     })
 
     it('Less than 0', () => {
-      expect(() => getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], -1)).toThrow()
+      expect(() =>
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], -1)
+      ).toThrow()
     })
 
     it('Greater than 255', () => {
-      expect(() => getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 256)).toThrow()
+      expect(() =>
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 256)
+      ).toThrow()
     })
 
     it('Decimal', () => {
-      expect(() => getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 100.4)).toThrow()
+      expect(() =>
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 100.4)
+      ).toThrow()
     })
   })
 
   describe('Rule 54 Iterations', () => {
     it('Generation 1', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 54)).toEqual([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 54)
+      ).toEqual([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0])
     })
     it('Generation 2', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], 54)).toEqual([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], 54)
+      ).toEqual([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0])
     })
     it('Generation 3', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0], 54)).toEqual([0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0], 54)
+      ).toEqual([0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0])
     })
     it('Generation 4', () => {
-      expect(getNextElementaryGeneration([0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0], 54)).toEqual([0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0], 54)
+      ).toEqual([0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0])
     })
   })
 
   describe('Rule 222 Iterations', () => {
     it('Generation 1', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 222)).toEqual([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 222)
+      ).toEqual([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0])
     })
     it('Generation 2', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], 222)).toEqual([0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], 222)
+      ).toEqual([0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0])
     })
     it('Generation 3', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0], 222)).toEqual([0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0], 222)
+      ).toEqual([0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0])
     })
     it('Generation 4', () => {
-      expect(getNextElementaryGeneration([0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0], 222)).toEqual([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0], 222)
+      ).toEqual([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0])
     })
   })
 
   describe('Rule 60 Iterations', () => {
     it('Generation 1', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 60)).toEqual([0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 60)
+      ).toEqual([0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0])
     })
     it('Generation 2', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0], 60)).toEqual([0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0], 60)
+      ).toEqual([0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0])
     })
     it('Generation 3', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0], 60)).toEqual([0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0], 60)
+      ).toEqual([0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0])
     })
     it('Generation 4', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0], 60)).toEqual([0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0], 60)
+      ).toEqual([0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0])
     })
   })
 
   describe('Rule 90 Iterations', () => {
     it('Generation 1', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 90)).toEqual([0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 90)
+      ).toEqual([0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0])
     })
     it('Generation 2', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0], 90)).toEqual([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0], 90)
+      ).toEqual([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0])
     })
     it('Generation 3', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0], 90)).toEqual([0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0], 90)
+      ).toEqual([0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0])
     })
     it('Generation 4', () => {
-      expect(getNextElementaryGeneration([0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0], 90)).toEqual([0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0], 90)
+      ).toEqual([0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0])
     })
   })
 
   describe('Rule 30 Iterations', () => {
     it('Generation 1', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 30)).toEqual([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 30)
+      ).toEqual([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0])
     })
     it('Generation 2', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], 30)).toEqual([0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], 30)
+      ).toEqual([0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0])
     })
     it('Generation 3', () => {
-      expect(getNextElementaryGeneration([0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0], 30)).toEqual([0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0])
+      expect(
+        getNextElementaryGeneration([0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0], 30)
+      ).toEqual([0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0])
     })
   })
 })