Rename test functions to use descriptive backtick names

Use Swift's backtick syntax for test function names to improve
readability in test output. Names now describe what each test verifies
rather than using abbreviated identifiers.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: tomasf

Tests/Tests/2D.swift

@@ -2,7 +2,7 @@ import Testing
 @testable import Cadova
 
 struct Geometry2DTests {
-    @Test func basic2D() async throws {
+    @Test func `2D boolean operations produce correct geometry`() async throws {
         try await Union {
             Rectangle(Vector2D(30, 10))
                 .aligned(at: .centerY)
@@ -19,7 +19,7 @@ struct Geometry2DTests {
         .expectEquals(goldenFile: "2d/basics")
     }
 
-    @Test func circular() async throws {
+    @Test func `circular shapes and overhang methods work correctly`() async throws {
         try await Union {
             Circle(diameter: 8)
                 .scaled(x: 2)
@@ -40,7 +40,7 @@ struct Geometry2DTests {
         .expectEquals(goldenFile: "2d/circular")
     }
 
-    @Test func roundedRectangle() async throws {
+    @Test func `rectangle corners can be rounded with edge profiles`() async throws {
         try await Rectangle(x: 10, y: 10)
             .cuttingEdgeProfile(.fillet(radius: 5), on: .bottomLeft)
             .cuttingEdgeProfile(.fillet(radius: 3), on: .bottomRight)

Tests/Tests/3D.swift

@@ -3,7 +3,7 @@ import Testing
 @testable import Cadova
 
 struct Geometry3DTests {
-    @Test func basic3D() async throws {
+    @Test func `3D boolean operations produce correct geometry`() async throws {
         try await Box([20, 20, 20])
             .aligned(at: .center)
             .intersecting {
@@ -17,14 +17,14 @@ struct Geometry3DTests {
             .expectEquals(goldenFile: "3d/basics")
     }
 
-    @Test func empty3D() async throws {
+    @Test func `empty boolean operations have no effect`() async throws {
         try await Box([10, 20, 30])
             .subtracting {}
             .adding {}
             .expectEquals(goldenFile: "3d/empty")
     }
 
-    @Test func roundedBoxes() async throws {
+    @Test func `box corners and edges can be rounded`() async throws {
         try await Stack(.x, spacing: 1) {
             Box([10, 8, 5])
                 .roundingBoxCorners(radius: 2)
@@ -39,7 +39,7 @@ struct Geometry3DTests {
         .expectEquals(goldenFile: "3d/rounded-box")
     }
 
-    @Test func cylinders() async throws {
+    @Test func `cylinders support various dimension specifications`() async throws {
         try await Stack(.y, spacing: 1) {
             Cylinder(bottomRadius: 3, topRadius: 6, height: 10)
             Cylinder(largerDiameter: 10, apexAngle: 10°, height: 20)

Tests/Tests/Anchors.swift

@@ -2,7 +2,7 @@ import Testing
 @testable import Cadova
 
 struct AnchorTests {
-    @Test func anchor() async throws {
+    @Test func `geometry can be positioned at an anchor point`() async throws {
         let boxRightSide = Anchor("right side of box")
 
         let geometry = Stack(.z, alignment: .center) {
@@ -21,7 +21,7 @@ struct AnchorTests {
         #expect(try await geometry.bounds ≈ .init(minimum: [-5, -5, 0], maximum: [15, 5, 14]))
     }
 
-    @Test func multipleDefinitions() async throws {
+    @Test func `anchor can be defined at multiple points on a shape`() async throws {
         let sphereSurface = Anchor("sphere's surface")
 
         let geometry = Box(1)
@@ -44,7 +44,7 @@ struct AnchorTests {
         #expect(try await geometry.bounds ≈ .init(minimum: .zero, maximum: [14, 14, 15]))
     }
 
-    @Test func usedBeforeDefinition() async throws {
+    @Test func `anchor can be used before it is defined`() async throws {
         let rightAnchor = Anchor("sphere's right side")
 
         let geometry = Box(1)

Tests/Tests/BezierCurve.swift

@@ -2,7 +2,7 @@ import Testing
 @testable import Cadova
 
 struct BezierCurveTests {
-    @Test func quadraticCurvePoints() {
+    @Test func `quadratic curve generates correct sample points`() {
         let curve = BezierPath2D.Curve(controlPoints: [
             [2.5, 8], [19.3, 25], [27, 10]
         ])
@@ -11,7 +11,7 @@ struct BezierCurveTests {
         #expect(points ≈ [[2.5, 8], [5.769, 11.08], [8.856, 13.52], [11.761, 15.32], [14.484, 16.48], [17.025, 17], [19.384, 16.88], [21.561, 16.12], [23.556, 14.72], [25.369, 12.68], [27, 10]])
     }
 
-    @Test func cubicCurvePoints() {
+    @Test func `cubic curve generates correct sample points`() {
         let curve = BezierPath2D.Curve(controlPoints: [
             [12.5, 8], [19.3, 25], [30.2, 12], [27, 10]
         ])
@@ -20,7 +20,7 @@ struct BezierCurveTests {
         #expect(points ≈ [[12.5, 8], [14.6448, 12.241], [16.9264, 14.928], [19.2356, 16.307], [21.4632, 16.624], [23.5, 16.125], [25.2368, 15.056], [26.5644, 13.663], [27.3736, 12.192], [27.5552, 10.889], [27, 10]])
     }
 
-    @Test func quartic3DCurvePoints() {
+    @Test func `quartic 3D curve generates correct sample points`() {
         let curve = BezierPath3D.Curve(controlPoints: [
             [11, 12.5, 8], [19.3, 56, 25], [30.2, 41.5, 12], [-12, 3.5, 20], [19, 27, 10]
         ])

Tests/Tests/BezierPatch.swift

@@ -2,7 +2,7 @@ import Testing
 @testable import Cadova
 
 struct BezierPatchTests {
-    @Test func basic() async throws {
+    @Test func `bezier patch can be enclosed into solid geometry`() async throws {
         let patch = BezierPatch(controlPoints: [
             [ [0, 0, 0],   [1, 0, 0.8],   [2, 0, -0.2],  [3, 0, 0] ],
             [ [0, 1, 0.5], [1, 1, 1.5],   [2, 1, 0.3],   [3, 1, -0.4] ],

Tests/Tests/BezierPath.swift

@@ -14,18 +14,18 @@ struct BezierPathTests {
         linearPath = BezierPath3D(linesBetween: linearPoints)
     }
 
-    @Test func quadraticPointsFixed() {
+    @Test func `quadratic path with fixed segmentation produces correct points`() {
         let points = quadraticPath.points(segmentation: .fixed(5))
         #expect(points ≈ [[39.1, 150], [31.456, 133.6], [23.724, 160.4], [15.904, 230.4], [7.996, 343.6], [0, 500], [118.12, 346.336], [216.48, 219.504], [295.08, 119.504], [353.92, 46.336], [393, 0]])
     }
 
-    @Test func quadraticPointsDynamic() {
+    @Test func `quadratic path with adaptive segmentation produces correct points`() {
         let points = quadraticPath.points(segmentation: .adaptive(minAngle: 10°, minSize: 20))
 
         #expect(points ≈ [[39.1, 150], [34.3328, 134.688], [29.5312, 136.25], [24.6953, 154.688], [22.2645, 170.234], [19.825, 190], [18.6021, 201.465], [17.377, 213.984], [16.1497, 227.559], [14.9203, 242.188], [13.6888, 257.871], [12.4551, 274.609], [11.2192, 292.402], [9.98125, 311.25], [8.74111, 331.152], [8.12024, 341.499], [7.49883, 352.109], [6.87688, 362.983], [6.25439, 374.121], [5.63137, 385.522], [5.00781, 397.188], [4.38372, 409.116], [3.75908, 421.309], [3.13391, 433.765], [2.5082, 446.484], [1.88196, 459.468], [1.25518, 472.715], [0.627856, 486.226], [0, 500], [9.9397, 487.029], [19.7588, 474.221], [29.4573, 461.578], [39.0352, 449.098], [48.4924, 436.781], [57.8291, 424.629], [67.0452, 412.64], [76.1406, 400.816], [85.1155, 389.155], [93.9697, 377.657], [102.703, 366.324], [111.316, 355.154], [119.809, 344.148], [128.181, 333.306], [136.432, 322.627], [144.562, 312.112], [152.573, 301.762], [160.462, 291.574], [168.231, 281.551], [175.879, 271.691], [183.406, 261.996], [190.813, 252.463], [198.1, 243.095], [205.266, 233.891], [212.311, 224.85], [219.235, 215.973], [226.039, 207.26], [232.723, 198.71], [239.285, 190.324], [245.728, 182.103], [252.049, 174.044], [258.25, 166.15], [270.29, 150.853], [281.848, 136.21], [292.923, 122.223], [303.516, 108.891], [313.626, 96.2135], [323.254, 84.1914], [332.399, 72.8244], [341.062, 62.1125], [349.243, 52.0557], [356.941, 42.6539], [364.157, 33.9072], [370.891, 25.8156], [382.91, 11.5977], [393, 0]])
     }
 
-    @Test func circle() async throws {
+    @Test func `circular arc produces correct control points and area`() async throws {
         let path = BezierPath2D(startPoint: [10, 0])
             .addingArc(center: .zero, to: 360°, clockwise: false)
 
@@ -43,7 +43,7 @@ struct BezierPathTests {
         #expect(floor(m.area) ≈ 314)
     }
 
-    @Test func arc() async throws {
+    @Test func `partial arc produces correct control points and bounds`() async throws {
         let path = BezierPath2D(startPoint: [10, 0])
             .addingArc(center: [1, 2], to: 100°, clockwise: false)
 

Tests/Tests/BezierPathBuilder.swift

@@ -2,7 +2,7 @@ import Testing
 @testable import Cadova
 
 struct BezierPathBuilderTests {
-    @Test func testAbsolute() {
+    @Test func `builder with absolute coordinates matches manual construction`() {
         let builderPath = BezierPath2D(from: [10, 4]) {
             line(x: 22, y: 1)
             line(x: 2)
@@ -30,7 +30,7 @@ struct BezierPathBuilderTests {
         #expect(builderPath ≈ manualPath)
     }
 
-    @Test func relativeArc() async throws {
+    @Test func `builder supports relative arc commands`() async throws {
         let builderPath = BezierPath2D(from: [-5, 0], mode: .relative) {
             line(y: 10)
             clockwiseArc(centerX: 5, angle: 180°)
@@ -45,7 +45,7 @@ struct BezierPathBuilderTests {
         #expect(builderPath ≈ manualPath)
     }
 
-    @Test func testRelative() {
+    @Test func `builder with relative coordinates matches manual construction`() {
         let builderPath = BezierPath2D(from: [10, 4], mode: .relative) {
             line(x: 22, y: 1)
             line(x: 2)

Tests/Tests/Bounds.swift

@@ -2,21 +2,21 @@ import Testing
 @testable import Cadova
 
 struct BoundsTests {
-    @Test func basicAlignment2D() async throws {
+    @Test func `2D shape alignment affects bounds`() async throws {
         let geometry = Rectangle([10, 4])
             .aligned(at: .centerX, .top)
 
         #expect(try await geometry.bounds ≈ .init(minimum: [-5, -4], maximum: [5, 0]))
     }
 
-    @Test func conflictingAlignment() async throws {
+    @Test func `conflicting alignments are resolved left to right`() async throws {
         let geometry = Rectangle([50, 20])
             .aligned(at: .minX, .centerX, .centerY, .maxX)
 
         #expect(try await geometry.bounds ≈ .init(minimum: [-50, -10], maximum: [0, 10]))
     }
 
-    @Test func repeatedAlignment() async throws {
+    @Test func `repeated alignments accumulate correctly`() async throws {
        let geometry = Box([10, 8, 12])
             .aligned(at: .minX)
             .aligned(at: .maxY)
@@ -27,7 +27,7 @@ struct BoundsTests {
         #expect(try await geometry.bounds ≈ .init(minimum: [-5, -4, 0], maximum: [5, 4, 12]))
     }
 
-    @Test func transformedBounds() async throws {
+    @Test func `bounds are correctly calculated after transforms`() async throws {
         let base = Box([10, 8, 12])
             .rotated(x: 90°)
             .translated(y: 12)
@@ -40,7 +40,7 @@ struct BoundsTests {
         #expect(try await extended.bounds ≈ .init(minimum: .zero, maximum: [28, 12, 10]))
     }
 
-    @Test func stack() async throws {
+    @Test func `stack computes combined bounds of children`() async throws {
         let geometry = Stack(.x, spacing: 1, alignment: .min) {
             Box([10, 8, 12])
             RegularPolygon(sideCount: 8, apothem: 3)

Tests/Tests/Cache.swift

@@ -7,7 +7,7 @@ struct GeometryCacheTests {
     let sphere = Sphere(diameter: 1)
     let box = Box(4)
 
-    @Test func basics() async throws {
+    @Test func `cache stores and reuses evaluation results`() async throws {
         _ = try await context.concrete(for: sphere)
         await #expect(context.cache3D.count == 1)
 
@@ -20,15 +20,15 @@ struct GeometryCacheTests {
         await #expect(context.cache3D.count == 3)
     }
 
-    @Test func differentEnvironments() async throws {
+    @Test func `different environments produce separate cache entries`() async throws {
         _ = try await context.concrete(for: sphere)
         await #expect(context.cache3D.count == 1)
 
         _ = try await context.concrete(for: sphere, in: .defaultEnvironment.withSegmentation(.fixed(10)))
         await #expect(context.cache3D.count == 2)
     }
 
-    @Test func warp() async throws {
+    @Test func `warp operations with same parameters share cache`() async throws {
         let scale = 2.0
         let warp1 = box.warped(operationName: "test", cacheParameters: scale) {
             Vector3D($0.x + $0.z * scale, $0.y, $0.z)
@@ -48,7 +48,7 @@ struct GeometryCacheTests {
         await #expect(context.cache3D.count == 2)
     }
 
-    @Test func split() async throws {
+    @Test func `split operation creates expected cache entries`() async throws {
         await #expect(context.cache3D.count == 0)
 
         let split1 = box.split(along: .z(2).rotated(x: 10°)) { g1, g2 in
@@ -59,8 +59,7 @@ struct GeometryCacheTests {
         await #expect(context.cache3D.count == 4) // box, 2x trims, split union
     }
 
-    // CachedConcreteTransformer should preserve elements
-    @Test func hullPreservesParts() async throws {
+    @Test func `convex hull preserves part information`() async throws {
         let model = Sphere(diameter: 10)
             .convexHull(adding: [0, 0, 20])
             .adding {
@@ -73,8 +72,7 @@ struct GeometryCacheTests {
         #expect(partNames == ["box"])
     }
 
-    // CachedConcreteArrayTransformer should preserve elements
-    @Test func splitPreservesParts() async throws {
+    @Test func `split preserves part information`() async throws {
         let model = Sphere(diameter: 10)
             .adding {
                 Box(5)

Tests/Tests/CircularOverhang.swift

@@ -2,7 +2,7 @@ import Testing
 @testable import Cadova
 
 struct CircularOverhangTests {
-    @Test func styles() async throws {
+    @Test func `circular overhang methods produce correct geometry`() async throws {
         try await Circle(diameter: 10)
             .overhangSafe()
             .extruded(height: 1)