Add tests for geometry formulas and calculations

Author: tomasf

.github/workflows/swift.yml

@@ -29,3 +29,6 @@ jobs:
     
     - name: Build
       run: swift build -v
+
+    - name: Test
+      run: swift test -v

Package.swift

@@ -22,6 +22,11 @@ let package = Package(
             name: "Demo",
             dependencies: ["Cadova", "Helical"],
             swiftSettings: [.interoperabilityMode(.Cxx)]
+        ),
+        .testTarget(
+            name: "HelicalTests",
+            dependencies: ["Helical", "Cadova"],
+            swiftSettings: [.interoperabilityMode(.Cxx)]
         )
     ]
 )

Tests/HelicalTests/CountersunkHeadTests.swift

@@ -0,0 +1,27 @@
+import Testing
+import Helical
+import Cadova
+
+private func isClose(_ a: Double, _ b: Double, tolerance: Double = 1e-9) -> Bool { abs(a - b) < tolerance }
+
+struct CountersunkHeadTests {
+    @Test func `height is (topDiameter - boltDiameter) / 2 × tan(angle / 2)`() {
+        let noLens = CountersunkBoltHeadShape(angle: 90°, topDiameter: 10, boltDiameter: 5)
+        #expect(isClose(noLens.height, 2.5, tolerance: 1e-6))
+
+        // 82° uses angle/2 = 41°, not the full angle
+        let angled = CountersunkBoltHeadShape(angle: 82°, topDiameter: 8, boltDiameter: 4)
+        #expect(isClose(angled.height, 2.0 * tan(41°), tolerance: 1e-6))
+    }
+
+    @Test func `lens height adds to total height but not consumed length`() {
+        let shape = CountersunkBoltHeadShape(angle: 90°, topDiameter: 10, boltDiameter: 5, lensHeight: 1)
+        #expect(isClose(shape.height, 3.5, tolerance: 1e-6))
+        #expect(isClose(shape.consumedLength, 2.5, tolerance: 1e-6))
+    }
+
+    @Test func `consumed length equals height minus lens height`() {
+        let shape = CountersunkBoltHeadShape(angle: 90°, topDiameter: 12, boltDiameter: 6, lensHeight: 1.5)
+        #expect(isClose(shape.consumedLength, shape.height - 1.5))
+    }
+}

Tests/HelicalTests/EdisonScrewTests.swift

@@ -0,0 +1,16 @@
+import Testing
+import Helical
+
+private func isClose(_ a: Double, _ b: Double, tolerance: Double = 1e-9) -> Bool { abs(a - b) < tolerance }
+
+struct EdisonScrewTests {
+    // pitchDiameter is computed via the knuckle threadform arc formula —
+    // several steps of non-trivial math over stored major/minor/pitch values.
+    @Test func `pitch diameter is computed correctly from arc formula`() {
+        // E27: h=1.25, pitch=3.62, radius≈0.96772 → pitchDiameter≈25.75
+        #expect(isClose(ScrewThread.e27.pitchDiameter, 25.75, tolerance: 1e-3))
+
+        // E5.5: radius=17/60, d=9/60=0.15 → pitchDiameter = 5.5 - 0.3 = 5.2 (exact)
+        #expect(isClose(ScrewThread.e5p5.pitchDiameter, 5.2, tolerance: 1e-6))
+    }
+}

Tests/HelicalTests/ISOMetricThreadTests.swift

@@ -0,0 +1,14 @@
+import Testing
+import Helical
+
+private func isClose(_ a: Double, _ b: Double) -> Bool { abs(a - b) < 1e-9 }
+
+struct ISOMetricThreadTests {
+    // The minor diameter is derived from major and pitch via the V-thread formula,
+    // not stored directly — worth verifying the formula constant is correct.
+    @Test func `minor diameter is major - pitch × 1.082532`() {
+        #expect(isClose(ScrewThread.m3.minorDiameter,  3.0  - 0.5  * 1.082532))
+        #expect(isClose(ScrewThread.m8.minorDiameter,  8.0  - 1.25 * 1.082532))
+        #expect(isClose(ScrewThread.m64.minorDiameter, 64.0 - 6.0  * 1.082532))
+    }
+}

Tests/HelicalTests/LeadInTests.swift

@@ -0,0 +1,61 @@
+import Testing
+@testable import Helical
+import Cadova
+
+private func isClose(_ a: Double, _ b: Double) -> Bool { abs(a - b) < 1e-9 }
+
+struct LeadInTests {
+    let m3 = ScrewThread.m3
+    let m8 = ScrewThread.m8
+
+    @Test func `constant(depth:length:) returns exact values`() {
+        let (depth, length) = LeadIn.constant(depth: 0.5, length: 1.0).resolved(for: m3)
+        #expect(depth == 0.5)
+        #expect(length == 1.0)
+    }
+
+    @Test func `constant(depth:) produces depth == length`() {
+        let (depth, length) = LeadIn.constant(depth: 0.3).resolved(for: m3)
+        #expect(depth == 0.3)
+        #expect(length == 0.3)
+    }
+
+    @Test func `depth(multiple:) scales by thread depth`() {
+        let (d1, l1) = LeadIn.depth(multiple: 1).resolved(for: m3)
+        #expect(isClose(d1, m3.depth))
+        #expect(isClose(l1, m3.depth))
+
+        let (d2, l2) = LeadIn.depth(multiple: 2).resolved(for: m8)
+        #expect(isClose(d2, m8.depth * 2))
+        #expect(isClose(l2, m8.depth * 2))
+    }
+
+    @Test func `pitch(multiple:) scales by thread pitch`() {
+        let (d1, l1) = LeadIn.pitch(multiple: 1).resolved(for: m3)
+        #expect(d1 == 0.5)
+        #expect(l1 == 0.5)
+
+        let (d2, l2) = LeadIn.pitch(multiple: 0.5).resolved(for: m8)
+        #expect(d2 == 0.625)
+        #expect(l2 == 0.625)
+    }
+
+    @Test func `angle(90°) produces 45° chamfer: depth == length`() {
+        let (depth, length) = LeadIn.angle(90°).resolved(for: m3)
+        #expect(isClose(depth, m3.depth))
+        #expect(isClose(length, depth))
+    }
+
+    @Test func `angle(120°) produces length = depth × tan(30°)`() {
+        let (depth, length) = LeadIn.angle(120°).resolved(for: m3)
+        #expect(isClose(depth, m3.depth))
+        #expect(isClose(length, depth * tan(30°)))
+    }
+
+    @Test func `standard equals depth(multiple: 1)`() {
+        let (d1, l1) = LeadIn.standard.resolved(for: m3)
+        let (d2, l2) = LeadIn.depth(multiple: 1).resolved(for: m3)
+        #expect(d1 == d2)
+        #expect(l1 == l2)
+    }
+}

Tests/HelicalTests/PhillipsTests.swift

@@ -0,0 +1,29 @@
+import Testing
+@testable import Helical
+import Cadova
+
+private func isClose(_ a: Double, _ b: Double) -> Bool { abs(a - b) < 1e-9 }
+
+// PhillipsMetrics.depth applies a two-term trig formula to stored constants.
+// These tests verify that both the stored constants and the formula are correct
+// by computing the expected depth from the ISO 4757 spec values independently.
+// depth = bottomWidth/2 × tan(28°) + (fullWidth/2 − bottomWidth/2) / tan(26.5°)
+struct PhillipsTests {
+    @Test func `PH0 depth matches formula with spec constants`() {
+        let m = PhillipsMetrics(size: .ph0, width: 1.8)
+        let expected = 0.81 / 2 * tan(28°) + (1.8 / 2 - 0.81 / 2) / tan(26.5°)
+        #expect(isClose(m.depth, expected))
+    }
+
+    @Test func `PH2 depth matches formula with spec constants`() {
+        let m = PhillipsMetrics(size: .ph2, width: 4.6)
+        let expected = 2.29 / 2 * tan(28°) + (4.6 / 2 - 2.29 / 2) / tan(26.5°)
+        #expect(isClose(m.depth, expected))
+    }
+
+    @Test func `PH4 depth matches formula with spec constants`() {
+        let m = PhillipsMetrics(size: .ph4, width: 9)
+        let expected = 5.08 / 2 * tan(28°) + (9.0 / 2 - 5.08 / 2) / tan(26.5°)
+        #expect(isClose(m.depth, expected))
+    }
+}

Tests/HelicalTests/ScrewThreadTests.swift

@@ -0,0 +1,30 @@
+import Testing
+@testable import Helical
+import Cadova
+
+private func isClose(_ a: Double, _ b: Double) -> Bool { abs(a - b) < 1e-9 }
+
+struct ScrewThreadTests {
+    @Test func `depth is (majorDiameter - minorDiameter) / 2`() {
+        // M3: major=3.0, minor=3.0 - 0.5*1.082532 = 2.458734
+        #expect(isClose(ScrewThread.m3.depth, 0.270633))
+
+        // Custom thread with exact integer values
+        let t = ScrewThread(pitch: 1.5, majorDiameter: 10, minorDiameter: 8, form: .trapezoidal(angle: 60°, crestWidth: 0.125))
+        #expect(t.depth == 1.0)
+    }
+
+    @Test func `lead is starts × pitch`() {
+        #expect(ScrewThread.m3.lead == 0.5)
+
+        // 3-start ACME thread: lead = 3 × 4 = 12
+        let t = ScrewThread.acme(majorDiameter: 20, pitch: 4, starts: 3)
+        #expect(t.lead == 12.0)
+    }
+
+    @Test func `leftHanded reflects handedness`() {
+        #expect(ScrewThread.m3.leftHanded == false)
+        let left = ScrewThread(handedness: .left, pitch: 0.5, majorDiameter: 3, minorDiameter: 2.458734, form: .trapezoidal(angle: 60°, crestWidth: 0.0625))
+        #expect(left.leftHanded == true)
+    }
+}

Tests/HelicalTests/StandardBoltTests.swift

@@ -0,0 +1,41 @@
+import Testing
+@testable import Helical
+import Cadova
+
+private func isClose(_ a: Double, _ b: Double, tolerance: Double = 1e-9) -> Bool { abs(a - b) < tolerance }
+
+// These tests verify that factory methods wire geometry correctly:
+// the table-sourced topDiameter feeds through the countersink height formula,
+// so a wrong table value or a wrong boltDiameter argument produces a wrong height.
+
+struct HexSocketCountersunkTests {
+    // boltDiameter = thread.majorDiameter (not majorDiameter - depth)
+    @Test func `head height uses major diameter as bolt diameter`() {
+        let m4  = Bolt.hexSocketCountersunk(.m4,  length: 20)
+        let m10 = Bolt.hexSocketCountersunk(.m10, length: 30)
+        // topDiameter=7.53, boltDiameter=4.0 → (7.53-4.0)/2 * tan(45°) ≈ 1.765
+        #expect(isClose(m4.headShape.height,  1.765, tolerance: 1e-4))
+        // topDiameter=19.22, boltDiameter=10.0 → (19.22-10.0)/2 ≈ 4.61
+        #expect(isClose(m10.headShape.height, 4.61,  tolerance: 1e-4))
+    }
+}
+
+struct TorxCountersunkTests {
+    // boltDiameter = majorDiameter - depth (not majorDiameter)
+    @Test func `head height uses reduced bolt diameter`() {
+        let m3 = Bolt.torxCountersunk(.m3, length: 20)
+        let m8 = Bolt.torxCountersunk(.m8, length: 30)
+        #expect(isClose(m3.headShape.height, (5.5  - (ScrewThread.m3.majorDiameter - ScrewThread.m3.depth)) / 2, tolerance: 1e-6))
+        #expect(isClose(m8.headShape.height, (15.8 - (ScrewThread.m8.majorDiameter - ScrewThread.m8.depth)) / 2, tolerance: 1e-6))
+    }
+}
+
+struct SlottedCountersunkTests {
+    // Same reduced boltDiameter convention as Torx
+    @Test func `head height uses reduced bolt diameter`() {
+        let m3  = Bolt.slottedCountersunk(.m3,  length: 20)
+        let m10 = Bolt.slottedCountersunk(.m10, length: 30)
+        #expect(isClose(m3.headShape.height,  (5.6  - (ScrewThread.m3.majorDiameter  - ScrewThread.m3.depth))  / 2, tolerance: 1e-6))
+        #expect(isClose(m10.headShape.height, (18.0 - (ScrewThread.m10.majorDiameter - ScrewThread.m10.depth)) / 2, tolerance: 1e-6))
+    }
+}

Tests/HelicalTests/ThreadformTests.swift

@@ -0,0 +1,48 @@
+import Testing
+import Helical
+import Cadova
+
+private func isClose(_ a: Double, _ b: Double, tolerance: Double = 1e-9) -> Bool { abs(a - b) < tolerance }
+
+struct TrapezoidalThreadformTests {
+    @Test func `angle is sum of both flank angles`() {
+        let symmetric = TrapezoidalThreadform(angle: 60°, crestWidth: 0.0625)
+        #expect(symmetric.angle == 60°)
+
+        let asymmetric = TrapezoidalThreadform(leadingFlankAngle: 7°, trailingFlankAngle: 45°, crestWidth: 0.1)
+        #expect(asymmetric.angle == 52°)
+    }
+
+    @Test func `pitch diameter formula`() {
+        // M3: major=3.0 + 2*(crestWidth - pitch/2)/(2*tan30°) ≈ 2.6752
+        let formM3 = TrapezoidalThreadform(angle: 60°, crestWidth: ScrewThread.m3.pitch / 8)
+        #expect(isClose(formM3.pitchDiameter(for: .m3), 2.6752, tolerance: 1e-4))
+
+        // M8: same formula ≈ 7.1881
+        let formM8 = TrapezoidalThreadform(angle: 60°, crestWidth: ScrewThread.m8.pitch / 8)
+        #expect(isClose(formM8.pitchDiameter(for: .m8), 7.1881, tolerance: 1e-4))
+    }
+
+    @Test func `minimum pitch formula`() {
+        // M3: crestWidth + depth*(tan30°+tan30°) = 0.0625 + 0.270633*2/√3 ≈ 0.375
+        let form = TrapezoidalThreadform(angle: 60°, crestWidth: ScrewThread.m3.pitch / 8)
+        #expect(isClose(form.minimumPitch(for: .m3), 0.375, tolerance: 1e-6))
+    }
+}
+
+struct KnuckleThreadformTests {
+    @Test func `minimum pitch is 2 × crest radius`() {
+        // E27: h=1.25, pitch=3.62 → radius=(1.5625+3.2761)/5 ≈ 0.96772
+        // minimumPitch = 2*radius ≈ 1.93544
+        let e27 = ScrewThread.e27
+        let h = (e27.majorDiameter - e27.minorDiameter) / 2
+        let r = (h * h + e27.pitch * e27.pitch / 4) / (4 * h)
+        let form: KnuckleThreadform = .knuckle(crestRadius: r, rootRadius: r)
+        #expect(isClose(form.minimumPitch(for: e27), 2 * r))
+        #expect(isClose(form.minimumPitch(for: e27), 1.93544, tolerance: 1e-4))
+    }
+
+    @Test func `pitch diameter formula`() {
+        #expect(isClose(ScrewThread.e27.pitchDiameter, 25.75, tolerance: 1e-3))
+    }
+}