Merge branch 'dev'

tomasf · tomasf · commit a6d4c91664ce · 2026-03-06T16:37:20.000+01:00
diff --git a/.github/workflows/swift.yml b/.github/workflows/swift.yml
@@ -30,3 +30,6 @@ jobs:
     
     - name: Build
       run: swift build -v
+
+    - name: Test
+      run: swift test -v
diff --git a/Package.resolved b/Package.resolved
diff --git a/Package.swift b/Package.swift
@@ -10,7 +10,7 @@ let package = Package(
         .executable(name: "Helical-Demo", targets: ["Demo"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/tomasf/Cadova.git", .upToNextMinor(from: "0.5.2")),
+        .package(url: "https://github.com/tomasf/Cadova.git", .upToNextMinor(from: "0.6.0")),
     ],
     targets: [
         .target(
@@ -22,6 +22,11 @@ let package = Package(
             name: "Demo",
             dependencies: ["Cadova", "Helical"],
             swiftSettings: [.interoperabilityMode(.Cxx)]
+        ),
+        .testTarget(
+            name: "HelicalTests",
+            dependencies: ["Helical", "Cadova"],
+            swiftSettings: [.interoperabilityMode(.Cxx)]
         )
     ]
 )
diff --git a/Sources/Demo/bolts.stl b/Sources/Demo/bolts.stl
diff --git a/Sources/Demo/main.swift b/Sources/Demo/main.swift
@@ -66,7 +66,11 @@ struct Repertoire: Shape3D {
     }
 }
 
-await Project(options: .format3D(.stl)) {
+await Project(packageRelative: "Models") {
+    Environment {
+        $0.segmentation = .adaptive(minAngle: 5°, minSize: 0.5)
+    }
+
     await Model("bolts") {
         Repertoire(contents: bolts)
     }
diff --git a/Sources/Demo/nutsAndWashers.stl b/Sources/Demo/nutsAndWashers.stl
diff --git a/Sources/Helical/Bolt/Parts/Sockets/Phillips.swift b/Sources/Helical/Bolt/Parts/Sockets/Phillips.swift
@@ -33,16 +33,16 @@ internal struct PhillipsMetrics: Sendable {
         switch size {
         case .ph0:
             crossDistanceBetweenCorners = 0.61
-            cornerWidth = 0.3
+            cornerWidth = 0.310
             bottomWidth = 0.81
             slotWidth = 0.35
             filletRadius = 0.3
-            cornerAcrossAngle = 135° //???
+            cornerAcrossAngle = 136°
             cornerSlant = 7°
 
         case .ph1:
             crossDistanceBetweenCorners = 0.97
-            cornerWidth = 0.45
+            cornerWidth = 0.435
             bottomWidth = 1.27
             slotWidth = 0.55
             filletRadius = 0.5
@@ -51,7 +51,7 @@ internal struct PhillipsMetrics: Sendable {
 
         case .ph2:
             crossDistanceBetweenCorners = 1.47
-            cornerWidth = 0.82
+            cornerWidth = 0.815
             bottomWidth = 2.29
             slotWidth = 0.7
             filletRadius = 0.6
@@ -60,7 +60,7 @@ internal struct PhillipsMetrics: Sendable {
 
         case .ph3:
             crossDistanceBetweenCorners = 2.41
-            cornerWidth = 2.0
+            cornerWidth = 2.005
             bottomWidth = 3.81
             slotWidth = 0.85
             filletRadius = 0.8
@@ -69,7 +69,7 @@ internal struct PhillipsMetrics: Sendable {
 
         case .ph4:
             crossDistanceBetweenCorners = 3.48
-            cornerWidth = 2.4
+            cornerWidth = 2.415
             bottomWidth = 5.08
             slotWidth = 1.25
             filletRadius = 1
diff --git a/Sources/Helical/Nut/Nut.swift b/Sources/Helical/Nut/Nut.swift
@@ -27,7 +27,9 @@ public struct Nut: Shape3D {
         let minorDiameter = thread.minorDiameter + tolerance
         shape
             .subtracting {
-                Screw(thread: thread, length: shape.threadedDepth)
+                let offset = 1e-3
+                Screw(thread: thread, length: shape.threadedDepth + 2 * offset)
+                    .translated(z: -offset)
 
                 if let (depth, length) = leadIns.leading?.resolved(for: thread) {
                     Cylinder(bottomDiameter: minorDiameter + 2 * depth, topDiameter: minorDiameter, height: length)
diff --git a/Tests/HelicalTests/CountersunkHeadTests.swift b/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))
+    }
+}
diff --git a/Tests/HelicalTests/EdisonScrewTests.swift b/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))
+    }
+}
diff --git a/Tests/HelicalTests/ISOMetricThreadTests.swift b/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))
+    }
+}
diff --git a/Tests/HelicalTests/LeadInTests.swift b/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)
+    }
+}
diff --git a/Tests/HelicalTests/PhillipsTests.swift b/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))
+    }
+}
diff --git a/Tests/HelicalTests/ScrewThreadTests.swift b/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)
+    }
+}
diff --git a/Tests/HelicalTests/StandardBoltTests.swift b/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))
+    }
+}
diff --git a/Tests/HelicalTests/ThreadformTests.swift b/Tests/HelicalTests/ThreadformTests.swift

Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,11 @@ struct Repertoire: Shape3D {`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`		`-await Project(options: .format3D(.stl)) {`
	`69`	`+await Project(packageRelative: "Models") {`
	`70`	`+ Environment {`
	`71`	`+ $0.segmentation = .adaptive(minAngle: 5°, minSize: 0.5)`
	`72`	`+ }`
	`73`	`+`
`70`	`74`	`await Model("bolts") {`
`71`	`75`	`Repertoire(contents: bolts)`
`72`	`76`	`}`