Improved formatting in various test files

Author: nikoscham

CONTRIBUTING.md

@@ -100,7 +100,11 @@ External contributors:
 Before submitting a pull request, test your modifications by running the FEAScript library from a local directory. For example, you can load the library in your HTML file as follows:
 
 ```javascript
-import { FEAScriptModel, plotSolution, printVersion } from "[USER_DIRECTORY]/FEAScript-core/src/index.js";
+import {
+  FEAScriptModel,
+  plotSolution,
+  printVersion,
+} from "[USER_DIRECTORY]/FEAScript-core/src/index.js";
 ```
 
 FEAScript can be run on a local server. You **must** start the server from the workspace root directory (the folder that contains both `FEAScript-core/` and `FEAScript-website/`), not from inside either subfolder. The HTML files use relative paths such as `../feascript-website.css` and `../../FEAScript-core/src/index.js` that only resolve correctly from that root.
@@ -127,4 +131,4 @@ Testing can be also performed at the Node.js environment. In this case you can a
 npm test
 ```
 
-These tests compare the numerical results against stored reference solutions at selected points.
+This command uses the Node.js test runner to discover all test files under `tests/`. The tests compare numerical results against stored reference solutions and verify individual solver and assembler behavior.

examples/eulerBernoulliBeamScript/README.md

@@ -1,4 +1,4 @@
-<img src="https://feascript.github.io/FEAScript-website/assets/feascript-structural-mechanics.png" width="80" alt="FEAScript Beam1DFEM Logo">
+<img src="https://feascript.github.io/FEAScript-website/assets/feascript-structural-mechanics.png" width="80" alt="FEAScript Euler-Bernoulli beam logo">
 
 # 1D Euler-Bernoulli Beam Examples
 
@@ -7,7 +7,7 @@ This directory contains Node.js examples demonstrating how to use the FEAScript
 
 ## Examples
 
-#### 1. Clamped and Spring-Supported Beam (`Beam1DEuler_Bernoulli.js`)
+#### 1. Clamped and Spring-Supported Beam (`clampedSpringSupportedBeam1D.js`)
 
 Reproduces the "Bending of a Beam" example from J.N. Reddy, _An Introduction to the Finite Element
 Method_, 3rd ed., McGraw-Hill, 2006 (FEM1D example problems, Chapter 7). A 10 m beam is clamped at
@@ -69,17 +69,20 @@ plus a point load):
 ```javascript
 model.addBoundaryCondition("1", [["fixed"]]); // w=0, theta=0 (clamped)
 model.addBoundaryCondition("2", [["pinned"], ["moment", 1250]]); // w=0, plus an applied moment
-model.addBoundaryCondition("3", [["spring", 200], ["force", -2500]]); // elastic support, plus a point load
+model.addBoundaryCondition("3", [
+  ["spring", 200],
+  ["force", -2500],
+]); // elastic support, plus a point load
 ```
 
-| Condition type                      | Kind             | Effect                                                    |
-| ------------------------------------ | ---------------- | ----------------------------------------------------------- |
-| `["fixed"]`                          | Essential         | `w = 0` and `theta = 0` (clamped support)                   |
-| `["pinned"]` / `["deflection", v]`   | Essential         | `w = v` (default `v = 0`; roller/pin support)                |
-| `["rotationFixed"]` / `["rotation", v]` | Essential      | `theta = v` (default `v = 0`)                                |
-| `["force", v]`                       | Natural           | Applies a concentrated transverse force `v` at the node       |
-| `["moment", v]`                      | Natural           | Applies a concentrated moment `v` at the node                 |
-| `["spring", k, uRef]`                | Mixed (Robin)     | Transverse elastic support of stiffness `k` about `uRef` (default `uRef = 0`) |
+| Condition type                          | Kind          | Effect                                                                        |
+| --------------------------------------- | ------------- | ----------------------------------------------------------------------------- |
+| `["fixed"]`                             | Essential     | `w = 0` and `theta = 0` (clamped support)                                     |
+| `["pinned"]` / `["deflection", v]`      | Essential     | `w = v` (default `v = 0`; roller/pin support)                                 |
+| `["rotationFixed"]` / `["rotation", v]` | Essential     | `theta = v` (default `v = 0`)                                                 |
+| `["force", v]`                          | Natural       | Applies a concentrated transverse force `v` at the node                       |
+| `["moment", v]`                         | Natural       | Applies a concentrated moment `v` at the node                                 |
+| `["spring", k, uRef]`                   | Mixed (Robin) | Transverse elastic support of stiffness `k` about `uRef` (default `uRef = 0`) |
 
 ## Running the Node.js Examples
 
@@ -98,5 +101,5 @@ npm install feascript
 #### 3. Run the example:
 
 ```bash
-node Beam1DEuler_Bernoulli.js
+node clampedSpringSupportedBeam1D/clampedSpringSupportedBeam1D.js
 ```

examples/eulerBernoulliBeamScript/clampedSpringSupportedBeam1D/clampedSpringSupportedBeam1D.js

@@ -7,33 +7,6 @@
  * ════════════════════════════════════════════════════════════════
  */
 
-/**
- * Clamped and spring-supported Euler-Bernoulli beam
- *
- * Reproduces the "Bending of a Beam" example from J.N. Reddy, "An Introduction to
- * the Finite Element Method", 3rd ed., McGraw-Hill, 2006 (FEM1D example problems,
- * Chapter 7), solved there with the reference FEM1D Fortran program (MODEL=3,
- * NTYPE=0, IELEM=0 i.e. Hermite cubic elements).
- *
- * Geometry: a 10 m beam, clamped at x=0, resting on a roller at midspan (x=5 m),
- * and connected to a linear transverse spring at the free end (x=10 m).
- * Mesh: 2 Hermite cubic beam elements of 5 m each -> 3 nodes: [1, 2, 3]
- *
- *        1,000 N/m (on 0 <= x <= 5)      2,500 N (down, at node 3)
- *        v v v v v v v v v v            |
- *   /////|--------------------|-------------------|       ~~~~ spring, k = 1e-4*EI
- *   ///// 1  (clamped)         2 (roller)          3 (free end, spring)
- *         |<-------- 5 m ----->|<------- 5 m ------>|
- *                    ^ moment 1,250 N-m applied at node 2
- *
- * EI = 2e6 N-m^2 (constant), k_spring = 1e-4 * EI = 200 N/m
- *
- * Boundary conditions (see beamBoundaryConditions.js for the condition syntax):
- *  - Node 1 (x=0):  fixed            -> w=0, theta=0     (clamped support)
- *  - Node 2 (x=5):  pinned + moment  -> w=0, applied moment M=1250 N-m
- *  - Node 3 (x=10): spring + force   -> k=200 N/m, applied point load P=-2500 N
- */
-
 // Import Math.js
 import * as math from "mathjs";
 global.math = math;
@@ -49,37 +22,37 @@ const model = new FEAScriptModel();
 // Select physics/PDE
 model.setModelConfig("eulerBernoulliBeamScript", {
   coefficientFunctions: {
-    EI: (x) => 2.0e6, // Bending stiffness E*I (N-m^2), constant along the beam
-    // Distributed transverse load: -1,000 N/m over the first (clamped) span only
+    EI: (x) => 2.0e6, // Bending stiffness
     q: (x) => (x <= 5 ? -1000 : 0),
-    // c0 defaults to 0 (no elastic foundation) when omitted
   },
 });
 
 // Define mesh configuration
-// elementOrder is 'linear' because that only describes the 2-node beam geometry;
-// the field itself is always interpolated with cubic Hermite shape functions internally
 model.setMeshConfig({
   meshDimension: "1D",
   elementOrder: "linear",
   numElementsX: 2,
   maxX: 10,
 });
 
-// Define boundary conditions (keyed by 1-based global node number)
+// Define boundary conditions
 model.addBoundaryCondition("1", [["fixed"]]); // Clamped support
 model.addBoundaryCondition("2", [["pinned"], ["moment", 1250]]); // Roller + applied moment
-model.addBoundaryCondition("3", [["spring", 200], ["force", -2500]]); // Spring support + point load
+model.addBoundaryCondition("3", [
+  ["spring", 200],
+  ["force", -2500],
+]); // Spring support + point load
 
 // Set solver method
 model.setSolverMethod("lusolve");
 
 // Solve the problem
 const { solutionVector } = model.solve();
 
-// The solution vector is ordered [w_0, theta_0, w_1, theta_1, w_2, theta_2, ...]
-// (mathjs' lusolve returns a nested array, so flatten defensively before reading it)
-const flatSolution = solutionVector.map((entry) => (Array.isArray(entry) ? entry[0] : entry));
+// Print results
+const flatSolution = solutionVector.map((entry) =>
+  Array.isArray(entry) ? entry[0] : entry
+);
 
 const nodeXCoordinates = [0, 5, 10];
 console.log("\nNode |    x (m) | Deflection w (m) | Rotation theta (rad)");
@@ -88,8 +61,10 @@ for (let nodeIndex = 0; nodeIndex < nodeXCoordinates.length; nodeIndex++) {
   const w = flatSolution[2 * nodeIndex];
   const theta = flatSolution[2 * nodeIndex + 1];
   console.log(
-    `  ${nodeIndex + 1}  | ${nodeXCoordinates[nodeIndex].toFixed(2).padStart(8)} | ${w
+    `  ${nodeIndex + 1}  | ${nodeXCoordinates[nodeIndex]
+      .toFixed(2)
+      .padStart(8)} | ${w.toExponential(4).padStart(17)} | ${theta
       .toExponential(4)
-      .padStart(17)} | ${theta.toExponential(4).padStart(20)}`,
+      .padStart(20)}`
   );
 }

package.json

@@ -20,7 +20,7 @@
     "build": "rollup -c",
     "prepare": "npm run build",
     "prepublishOnly": "npm run build",
-    "test": "node tests/run-all-tests.js",
+    "test": "node --test tests",
     "format": "prettier --write ."
   },
   "repository": {

src/mesh/meshUtils.js

@@ -238,7 +238,7 @@ export function performIsoparametricMapping2D(params) {
 
 /**
  * Function to test if a point is inside a triangle using barycentric coordinates,
- * also returning the natural coordinates (ksi, eta).
+ * also returning the natural coordinates (ksi, eta)
  * @param {number} x - X-coordinate of the point
  * @param {number} y - Y-coordinate of the point
  * @param {array} vertices - Triangle vertices [[x0,y0],[x1,y1],[x2,y2]]

src/models/beamBoundaryConditions.js

@@ -121,11 +121,7 @@ export class BeamBoundaryConditions {
         } else if (conditionType === "rotationFixed" || conditionType === "rotation") {
           applyDirichlet(rotationDOF, value ?? 0);
           debugLog(`Node ${nodeKey}: Applied rotation theta=${value ?? 0} (essential BC)`);
-        } else if (
-          conditionType !== "force" &&
-          conditionType !== "moment" &&
-          conditionType !== "spring"
-        ) {
+        } else if (conditionType !== "force" && conditionType !== "moment" && conditionType !== "spring") {
           errorLog(`Unknown beam boundary condition type: "${conditionType}"`);
         }
       });

src/models/eulerBernoulliBeam.js

@@ -81,7 +81,10 @@ export function assembleEulerBernoulliBeamMat(meshData, boundaryConditions, coef
 
   // Cubic Hermite basis functions for the field, with a 4-point Gauss quadrature rule
   const basisFunctions = new BasisFunctions({ meshDimension: "1D", elementOrder: "hermiteCubic" });
-  const numericalIntegration = new NumericalIntegration({ meshDimension: "1D", elementOrder: "hermiteCubic" });
+  const numericalIntegration = new NumericalIntegration({
+    meshDimension: "1D",
+    elementOrder: "hermiteCubic",
+  });
   const { gaussPoints, gaussWeights } = numericalIntegration.getGaussPointsAndWeights();
 
   // Matrix assembly

src/visualization/vtkPlot.js

@@ -492,7 +492,7 @@ function convertElementNodesToLinearCell(elementNodes) {
     return [indices[0], indices[6], indices[8], indices[2]];
   }
 
-  // Generic fallback for polygonal/high-order cells.
+  // Generic fallback for polygonal/high-order cells
   return indices.slice(0, Math.min(4, indices.length));
 }
 
@@ -546,15 +546,23 @@ function buildVTPString(vtkData) {
     '<?xml version="1.0"?>',
     '<VTKFile type="PolyData" version="0.1" byte_order="LittleEndian">',
     "  <PolyData>",
-    `    <Piece NumberOfPoints="${numberOfPoints}" NumberOfVerts="0" NumberOfLines="${isLine ? offsets.length : 0}" NumberOfStrips="0" NumberOfPolys="${isLine ? 0 : offsets.length}">`,
+    `    <Piece NumberOfPoints="${numberOfPoints}" NumberOfVerts="0" NumberOfLines="${
+      isLine ? offsets.length : 0
+    }" NumberOfStrips="0" NumberOfPolys="${isLine ? 0 : offsets.length}">`,
     '      <PointData Scalars="solution">',
-    `        <DataArray type="Float32" Name="solution" NumberOfComponents="1" format="ascii">${Array.from(vtkData.scalars).join(" ")}</DataArray>`,
+    `        <DataArray type="Float32" Name="solution" NumberOfComponents="1" format="ascii">${Array.from(
+      vtkData.scalars,
+    ).join(" ")}</DataArray>`,
     "      </PointData>",
     "      <Points>",
-    `        <DataArray type="Float32" NumberOfComponents="3" format="ascii">${Array.from(vtkData.points).join(" ")}</DataArray>`,
+    `        <DataArray type="Float32" NumberOfComponents="3" format="ascii">${Array.from(
+      vtkData.points,
+    ).join(" ")}</DataArray>`,
     "      </Points>",
     `      <${topologyTag}>`,
-    `        <DataArray type="Int32" Name="connectivity" format="ascii">${connectivity.join(" ")}</DataArray>`,
+    `        <DataArray type="Int32" Name="connectivity" format="ascii">${connectivity.join(
+      " ",
+    )}</DataArray>`,
     `        <DataArray type="Int32" Name="offsets" format="ascii">${offsets.join(" ")}</DataArray>`,
     `      </${topologyTag}>`,
     "    </Piece>",

src/workers/worker.js

@@ -16,7 +16,7 @@ import * as Comlink from "../vendor/comlink.mjs";
 export class FEAScriptWorker {
   /**
    * Constructor to initialize the FEAScriptWorker class
-   * Sets up the worker and initializes the workerWrapper.
+   * Sets up the worker and initializes the workerWrapper
    */
   constructor() {
     this.worker = null;

tests/regression/EulerBernoulliBeam/REGRESSION.md

@@ -6,35 +6,35 @@ This test guards the numerical output of the 1D Euler-Bernoulli beam example aga
 unintended changes to the beam solver, assembler, or mesh-generation logic.
 
 It replicates exactly the problem set up in
-[`Beam1DEuler_Bernoulli.js`](../../../examples/Beam1DFEM/Beam1DEuler_Bernoulli.js) — the
+[`clampedSpringSupportedBeam1D.js`](../../../examples/eulerBernoulliBeamScript/clampedSpringSupportedBeam1D/clampedSpringSupportedBeam1D.js) — the
 "Bending of a Beam" example from J.N. Reddy, _An Introduction to the Finite Element Method_,
 3rd ed., McGraw-Hill, 2006 (FEM1D example problems, Chapter 7) — and asserts both a set of
 known-good baseline values and, independently of those baseline numbers, that the resulting
 finite element solution satisfies global static equilibrium.
 
 ## Problem setup
 
-| Parameter                    | Value                                                   |
-| ----------------------------- | -------------------------------------------------------- |
-| Domain                        | 1D beam, 0 – 10 m                                        |
-| Mesh                          | 2 cubic Hermite beam elements of 5 m each (3 nodes)      |
-| Bending stiffness EI          | 2.0 × 10⁶ N·m² (constant)                                |
-| Distributed load              | −1,000 N/m over 0 ≤ x ≤ 5 m only                          |
-| Node 1 (x = 0)                | Fixed (clamped): w = 0, theta = 0                        |
-| Node 2 (x = 5)                | Pinned (roller): w = 0, plus an applied moment M = 1,250 N·m |
-| Node 3 (x = 10)               | Transverse spring k = 200 N/m, plus a point load P = −2,500 N |
-| Solver                        | LU decomposition (`lusolve`)                              |
+| Parameter            | Value                                                         |
+| -------------------- | ------------------------------------------------------------- |
+| Domain               | 1D beam, 0 – 10 m                                             |
+| Mesh                 | 2 cubic Hermite beam elements of 5 m each (3 nodes)           |
+| Bending stiffness EI | 2.0 × 10⁶ N·m² (constant)                                     |
+| Distributed load     | −1,000 N/m over 0 ≤ x ≤ 5 m only                              |
+| Node 1 (x = 0)       | Fixed (clamped): w = 0, theta = 0                             |
+| Node 2 (x = 5)       | Pinned (roller): w = 0, plus an applied moment M = 1,250 N·m  |
+| Node 3 (x = 10)      | Transverse spring k = 200 N/m, plus a point load P = −2,500 N |
+| Solver               | LU decomposition (`lusolve`)                                  |
 
 ## Expected values
 
-| Quantity                | Value                     |
-| ------------------------ | ------------------------- |
-| w₁ (deflection, node 1)  | 0 m                        |
-| θ₁ (rotation, node 1)    | 0 rad                      |
-| w₂ (deflection, node 2)  | 0 m                        |
-| θ₂ (rotation, node 2)    | −5.6790761806 × 10⁻³ rad   |
-| w₃ (deflection, node 3)  | −8.0144777663 × 10⁻² m     |
-| θ₃ (rotation, node 3)    | −2.1203895209 × 10⁻² rad   |
+| Quantity                | Value                    |
+| ----------------------- | ------------------------ |
+| w₁ (deflection, node 1) | 0 m                      |
+| θ₁ (rotation, node 1)   | 0 rad                    |
+| w₂ (deflection, node 2) | 0 m                      |
+| θ₂ (rotation, node 2)   | −5.6790761806 × 10⁻³ rad |
+| w₃ (deflection, node 3) | −8.0144777663 × 10⁻² m   |
+| θ₃ (rotation, node 3)   | −2.1203895209 × 10⁻² rad |
 
 Tolerance used in the baseline assertions: `1e-8`.
 
@@ -77,16 +77,24 @@ node tests/regression/EulerBernoulliBeam/regression.test.js
 
 The `test` script in `package.json` also runs this file, so `npm test` works too.
 
+A passing run prints a `PASS:` line for each check, followed by a summary line:
+
+```
+8 passed, 0 failed.
+```
+
+A failing run prints one or more `FAIL:` lines, ends with the same summary line format, and exits with code 1.
+
 ## After modifying the code
 
-| Situation                                                                    | Action                                                                                                    |
-| ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ |
-| Bug fix that should not change results                                       | Run the test — it must still pass.                                                                        |
-| Intentional algorithm change (new integration rule, new element type, etc.)  | Re-derive the expected values, update `EXPECTED` in `regression.test.js`, and document the reason here.  |
-| New boundary condition type                                                  | Update both the test and `Beam1DEuler_Bernoulli.js` together.                                             |
+| Situation                                                                   | Action                                                                                                  |
+| --------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| Bug fix that should not change results                                      | Run the test — it must still pass.                                                                      |
+| Intentional algorithm change (new integration rule, new element type, etc.) | Re-derive the expected values, update `EXPECTED` in `regression.test.js`, and document the reason here. |
+| New boundary condition type                                                 | Update both the test and `clampedSpringSupportedBeam1D.js` together.                                    |
 
 ## Change log
 
 | Date       | Change                      | New expected values |
-| ---------- | ---------------------------- | -------------------- |
-| 2026-07-17 | Initial regression baseline | See table above      |
+| ---------- | --------------------------- | ------------------- |
+| 2026-07-17 | Initial regression baseline | See table above     |