Diagramme rechnen mit der vollen Länge, eigene Symbole für CPU und GPU

Frisch gestartet hat der Verlauf fünf Messwerte statt sechzig. Gerechnet
wurde aber „Breite geteilt durch Anzahl" — also war jeder Balken ein
Fünftel breit, und mit jedem weiteren wurden sie schmaler. Das Diagramm sah
nach einem Ausschlag aus und bedeutete nichts.

Jetzt kommt die Schrittweite aus der vollen Länge. Fehlende Werte bleiben
als freie Fläche links stehen; der Verlauf wächst nach links weg, wie bei
jedem Zeitdiagramm.

Das steckte an **drei** Stellen, alle mit derselben Rechnung: dem
Balkendiagramm im Netzwerk-Popover, der Sparkline in den Kacheln und der
Linie in den Menüleisten-Modulen. Die gemeinsame Rechnung liegt jetzt in
`GraphLayout` und ist geprüft, statt dreimal danebenzugehen.

Nebenbei: die Fläche unter der Sparkline begann am linken Rand statt am
ersten Messwert — ein Keil über die ganze Breite, wo noch nichts gemessen
war.

CPU und GPU bekommen eigene Symbole aus chip.svg und graphic-card.svg. SF
Symbols hat für beides nur denselben Chip, und „cpu" neben „cpu.fill" ist
kein Unterschied, den man in der Menüleiste erkennt.

Die Beschriftung unter den Ringen klebte am Rand und sah aus, als gehörte
sie noch hinein — sechs Punkte Abstand statt zwei. Und die Popover für CPU
und GPU tragen jetzt einen Titel: bei drei gleich aussehenden Ringen sieht
man sonst nicht, vor welchem man steht.

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

Packages/OnyxKit/Tests/OnyxMenuBarTests/GraphLayoutTests.swift

@@ -0,0 +1,78 @@
+import Testing
+import CoreGraphics
+@testable import OnyxMenuBar
+
+// Frisch gestartet hat der Verlauf zwei Messwerte statt sechzig. Wurde die
+// Schrittweite aus der vorhandenen Anzahl gerechnet, spannte sich der Weg
+// zwischen ihnen über die ganze Breite — ein riesiger Zickzack, der nach viel
+// Bewegung aussah und nichts bedeutete.
+
+@Suite("Verlaufsdiagramm")
+struct GraphLayoutTests {
+
+    private let rect = CGRect(x: 0, y: 0, width: 60, height: 10)
+
+    @Test("Bei vollem Verlauf reicht er von Rand zu Rand")
+    func fullHistorySpansTheWidth() {
+        let xs = GraphLayout.positions(count: 60, capacity: 60, in: rect)
+        #expect(xs.first == rect.minX)
+        #expect(abs(xs.last! - rect.maxX) < 0.001)
+    }
+
+    @Test("Wenige Werte behalten dieselbe Schrittweite")
+    func fewValuesKeepTheStep() {
+        // Der Kern: zwei Messwerte stehen so eng wie zwei von sechzig, nicht
+        // über die volle Breite verteilt.
+        let full = GraphLayout.positions(count: 60, capacity: 60, in: rect)
+        let few = GraphLayout.positions(count: 2, capacity: 60, in: rect)
+        let fullStep = full[1] - full[0]
+        #expect(abs((few[1] - few[0]) - fullStep) < 0.001)
+    }
+
+    @Test("Neue Werte stehen rechts")
+    func newValuesAreOnTheRight() {
+        // Der Verlauf wächst nach links weg, wie bei jedem Zeitdiagramm.
+        let xs = GraphLayout.positions(count: 3, capacity: 60, in: rect)
+        #expect(abs(xs.last! - rect.maxX) < 0.001)
+        #expect(xs.first! > rect.midX)
+    }
+
+    @Test("Unter zwei Werten gibt es nichts zu zeichnen")
+    func lessThanTwoDrawsNothing() {
+        // Eine Linie braucht zwei Punkte. Einen zu zeichnen ergäbe einen
+        // Strich am Rand, der wie ein Messwert aussieht.
+        #expect(GraphLayout.positions(count: 1, capacity: 60, in: rect).isEmpty)
+        #expect(GraphLayout.positions(count: 0, capacity: 60, in: rect).isEmpty)
+    }
+
+    @Test("Mehr Werte als Platz laufen nicht über")
+    func overflowIsClamped() {
+        let xs = GraphLayout.positions(count: 200, capacity: 60, in: rect)
+        #expect(xs.allSatisfy { $0 >= rect.minX - 0.001 && $0 <= rect.maxX + 0.001 })
+    }
+}
+
+@Suite("Balkendiagramm")
+struct BarLayoutTests {
+
+    @Test("Die Balkenbreite hängt nicht an der Anzahl der Werte")
+    func barWidthIsIndependentOfCount() {
+        // Der Fehler, um den es geht: bei fünf Messwerten war jeder Balken ein
+        // Fünftel breit, und mit jedem weiteren wurden sie schmaler.
+        let a = GraphLayout.barWidth(capacity: 60, totalWidth: 300, spacing: 1)
+        #expect(a == GraphLayout.barWidth(capacity: 60, totalWidth: 300, spacing: 1))
+    }
+
+    @Test("Alle Balken samt Abstand füllen die Breite")
+    func barsFillTheWidth() {
+        let width = GraphLayout.barWidth(capacity: 60, totalWidth: 300, spacing: 1)
+        let total = 60 * width + 59 * 1
+        #expect(abs(total - 300) < 0.001)
+    }
+
+    @Test("Ein Balken bleibt sichtbar, auch wenn es eng wird")
+    func barsStayVisible() {
+        // Sonst verschwindet der Verlauf bei schmalem Popover ganz.
+        #expect(GraphLayout.barWidth(capacity: 500, totalWidth: 100, spacing: 1) >= 0.5)
+    }
+}