Make 'values' on TestCounter, TestRecorder and TestMeter public (#129)

Co-authored-by: Hamzah Malik <hamzah_malik@apple.com>

Sources/MetricsTestKit/TestMetrics.swift

@@ -324,20 +324,22 @@ public final class TestCounter: TestMetric, CounterHandler, Equatable {
     }
 
     public var lastValue: Int64? {
-        return self.values.last?.1
+        return self.last?.1
     }
 
     public var totalValue: Int64 {
-        return self.values.map { $0.1 }.reduce(0, +)
+        return self.values.reduce(0, +)
     }
 
     public var last: (Date, Int64)? {
-        return self.values.last
+        return self.lock.withLock {
+            self._values.last
+        }
     }
 
-    var values: [(Date, Int64)] {
+    public var values: [Int64] {
         return self.lock.withLock {
-            self._values
+            self._values.map { $0.1 }
         }
     }
 
@@ -396,12 +398,14 @@ public final class TestMeter: TestMetric, MeterHandler, Equatable {
     }
 
     public var last: (Date, Double)? {
-        return self.values.last
+        return self.lock.withLock {
+            self._values.last
+        }
     }
 
-    var values: [(Date, Double)] {
+    public var values: [Double] {
         return self.lock.withLock {
-            self._values
+            self._values.map { $0.1 }
         }
     }
 
@@ -446,12 +450,14 @@ public final class TestRecorder: TestMetric, RecorderHandler, Equatable {
     }
 
     public var last: (Date, Double)? {
-        return self.values.last
+        return self.lock.withLock {
+            self._values.last
+        }
     }
 
-    var values: [(Date, Double)] {
+    public var values: [Double] {
         return self.lock.withLock {
-            self._values
+            self._values.map { $0.1 }
         }
     }
 
@@ -486,14 +492,12 @@ public final class TestTimer: TestMetric, TimerHandler, Equatable {
         }
     }
 
-    func retrieveValueInPreferredUnit(atIndex i: Int) -> Double {
+    public func valueInPreferredUnit(atIndex i: Int) -> Double {
-        return self.lock.withLock {
+        let value = self.values[i]
-            let value = _values[i].1
+        guard let displayUnit = self.displayUnit else {
-            guard let displayUnit = self.displayUnit else {
+            return Double(value)
-                return Double(value)
-            }
-            return Double(value) / Double(displayUnit.scaleFromNanoseconds)
         }
+        return Double(value) / Double(displayUnit.scaleFromNanoseconds)
     }
 
     public func recordNanoseconds(_ duration: Int64) {
@@ -503,9 +507,7 @@ public final class TestTimer: TestMetric, TimerHandler, Equatable {
     }
 
     public var lastValue: Int64? {
-        return self.lock.withLock {
+        return self.last?.1
-            return self._values.last?.1
-        }
     }
 
     public var values: [Int64] {

Tests/MetricsTests/CoreMetricsTests.swift

@@ -13,7 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 @testable import CoreMetrics
-@testable import MetricsTestKit
+import MetricsTestKit
 import XCTest
 
 class MetricsTests: XCTestCase {
@@ -49,7 +49,7 @@ class MetricsTests: XCTestCase {
         Counter(label: name).increment(by: value)
         let counter = try metrics.expectCounter(name)
         XCTAssertEqual(counter.values.count, 1, "expected number of entries to match")
-        XCTAssertEqual(counter.values[0].1, Int64(value), "expected value to match")
+        XCTAssertEqual(counter.values[0], Int64(value), "expected value to match")
         counter.reset()
         XCTAssertEqual(counter.values.count, 0, "expected number of entries to match")
     }
@@ -112,7 +112,7 @@ class MetricsTests: XCTestCase {
         fpCounter.increment(by: Double(sign: .plus, exponent: 63, significand: 1))
         // Much larger than Int64
         fpCounter.increment(by: Double.greatestFiniteMagnitude)
-        let values = counter.values.map { $0.1 }
+        let values = counter.values
         XCTAssertEqual(values.count, 2, "expected number of entries to match")
         XCTAssertEqual(values, [Int64.max, Int64.max], "expected extremely large values to be replaced with Int64.max")
     }
@@ -132,7 +132,7 @@ class MetricsTests: XCTestCase {
 
         // Increment by a small value that should grow the accumulated buffer past 1.0 (perfectly representable)
         fpCounter.increment(by: 1.5)
-        var values = counter.values.map { $0.1 }
+        var values = counter.values
         XCTAssertEqual(values.count, 1, "expected number of entries to match")
         XCTAssertEqual(values, [2], "expected entries to match")
         XCTAssertEqual(rawFpCounter.fraction, 0.25, "")
@@ -140,7 +140,7 @@ class MetricsTests: XCTestCase {
         // Increment by a large value that should leave a fraction in the accumulator
         // 1110506744053.76
         fpCounter.increment(by: Double(sign: .plus, exponent: 40, significand: 1.01))
-        values = counter.values.map { $0.1 }
+        values = counter.values
         XCTAssertEqual(values.count, 2, "expected number of entries to match")
         XCTAssertEqual(values, [2, 1_110_506_744_054], "expected entries to match")
         XCTAssertEqual(rawFpCounter.fraction, 0.010009765625, "expected fractional accumulated value")
@@ -178,7 +178,7 @@ class MetricsTests: XCTestCase {
         }
         XCTAssertEqual(values.count, testRecorder.values.count, "expected number of entries to match")
         for i in 0 ... values.count - 1 {
-            XCTAssertEqual(Int32(testRecorder.values[i].1), values[i], "expected value #\(i) to match.")
+            XCTAssertEqual(Int32(testRecorder.values[i]), values[i], "expected value #\(i) to match.")
         }
     }
 
@@ -194,7 +194,7 @@ class MetricsTests: XCTestCase {
         }
         XCTAssertEqual(values.count, testRecorder.values.count, "expected number of entries to match")
         for i in 0 ... values.count - 1 {
-            XCTAssertEqual(Float(testRecorder.values[i].1), values[i], "expected value #\(i) to match.")
+            XCTAssertEqual(Float(testRecorder.values[i]), values[i], "expected value #\(i) to match.")
         }
     }
 
@@ -373,7 +373,7 @@ class MetricsTests: XCTestCase {
         meter.set(value)
         let testMeter = meter._handler as! TestMeter
         XCTAssertEqual(testMeter.values.count, 1, "expected number of entries to match")
-        XCTAssertEqual(testMeter.values[0].1, value, "expected value to match")
+        XCTAssertEqual(testMeter.values[0], value, "expected value to match")
     }
 
     func testMeterBlock() throws {
@@ -386,7 +386,7 @@ class MetricsTests: XCTestCase {
         Meter(label: name).set(value)
         let testMeter = try metrics.expectMeter(name)
         XCTAssertEqual(testMeter.values.count, 1, "expected number of entries to match")
-        XCTAssertEqual(testMeter.values[0].1, value, "expected value to match")
+        XCTAssertEqual(testMeter.values[0], value, "expected value to match")
     }
 
     func testMUX_Counter() throws {
@@ -424,7 +424,7 @@ class MetricsTests: XCTestCase {
             let meter = factory.meters.first
             XCTAssertEqual(meter?.label, name, "expected label to match")
             XCTAssertEqual(meter?.values.count, 1, "expected number of entries to match")
-            XCTAssertEqual(meter?.values[0].1, value, "expected value to match")
+            XCTAssertEqual(meter?.values[0], value, "expected value to match")
         }
     }
 
@@ -441,7 +441,7 @@ class MetricsTests: XCTestCase {
             let recorder = factory.recorders.first
             XCTAssertEqual(recorder?.label, name, "expected label to match")
             XCTAssertEqual(recorder?.values.count, 1, "expected number of entries to match")
-            XCTAssertEqual(recorder?.values[0].1, value, "expected value to match")
+            XCTAssertEqual(recorder?.values[0], value, "expected value to match")
         }
     }
 
@@ -460,7 +460,7 @@ class MetricsTests: XCTestCase {
             XCTAssertEqual(timer?.values.count, 1, "expected number of entries to match")
             XCTAssertEqual(timer?.values[0], Int64(seconds * 1_000_000_000), "expected value to match")
             XCTAssertEqual(timer?.displayUnit, .minutes, "expected value to match")
-            XCTAssertEqual(timer?.retrieveValueInPreferredUnit(atIndex: 0), Double(seconds) / 60.0, "seconds should be returned as minutes")
+            XCTAssertEqual(timer?.valueInPreferredUnit(atIndex: 0), Double(seconds) / 60.0, "seconds should be returned as minutes")
         }
     }
 
@@ -488,7 +488,7 @@ class MetricsTests: XCTestCase {
 
         let recorder = gauge._handler as! TestRecorder
         XCTAssertEqual(recorder.values.count, 1, "expected number of entries to match")
-        XCTAssertEqual(recorder.values.first!.1, value, "expected value to match")
+        XCTAssertEqual(recorder.values.first, value, "expected value to match")
         XCTAssertEqual(metrics.recorders.count, 1, "recorder should have been stored")
 
         let identity = ObjectIdentifier(recorder)
@@ -500,7 +500,7 @@ class MetricsTests: XCTestCase {
 
         let recorderAgain = gaugeAgain._handler as! TestRecorder
         XCTAssertEqual(recorderAgain.values.count, 1, "expected number of entries to match")
-        XCTAssertEqual(recorderAgain.values.first!.1, -value, "expected value to match")
+        XCTAssertEqual(recorderAgain.values.first, -value, "expected value to match")
 
         let identityAgain = ObjectIdentifier(recorderAgain)
         XCTAssertNotEqual(identity, identityAgain, "since the cached metric was released, the created a new should have a different identity")
@@ -518,7 +518,7 @@ class MetricsTests: XCTestCase {
 
         let testMeter = meter._handler as! TestMeter
         XCTAssertEqual(testMeter.values.count, 1, "expected number of entries to match")
-        XCTAssertEqual(testMeter.values.first!.1, value, "expected value to match")
+        XCTAssertEqual(testMeter.values.first, value, "expected value to match")
         XCTAssertEqual(metrics.meters.count, 1, "recorder should have been stored")
 
         let identity = ObjectIdentifier(testMeter)
@@ -530,7 +530,7 @@ class MetricsTests: XCTestCase {
 
         let testMeterAgain = meterAgain._handler as! TestMeter
         XCTAssertEqual(testMeterAgain.values.count, 1, "expected number of entries to match")
-        XCTAssertEqual(testMeterAgain.values.first!.1, -value, "expected value to match")
+        XCTAssertEqual(testMeterAgain.values.first, -value, "expected value to match")
 
         let identityAgain = ObjectIdentifier(testMeterAgain)
         XCTAssertNotEqual(identity, identityAgain, "since the cached metric was released, the created a new should have a different identity")
@@ -548,7 +548,7 @@ class MetricsTests: XCTestCase {
 
         let testCounter = counter._handler as! TestCounter
         XCTAssertEqual(testCounter.values.count, 1, "expected number of entries to match")
-        XCTAssertEqual(testCounter.values.first!.1, Int64(value), "expected value to match")
+        XCTAssertEqual(testCounter.values.first, Int64(value), "expected value to match")
         XCTAssertEqual(metrics.counters.count, 1, "counter should have been stored")
 
         let identity = ObjectIdentifier(counter)
@@ -560,7 +560,7 @@ class MetricsTests: XCTestCase {
 
         let testCounterAgain = counterAgain._handler as! TestCounter
         XCTAssertEqual(testCounterAgain.values.count, 1, "expected number of entries to match")
-        XCTAssertEqual(testCounterAgain.values.first!.1, Int64(value), "expected value to match")
+        XCTAssertEqual(testCounterAgain.values.first, Int64(value), "expected value to match")
 
         let identityAgain = ObjectIdentifier(counterAgain)
         XCTAssertNotEqual(identity, identityAgain, "since the cached metric was released, the created a new should have a different identity")

Tests/MetricsTests/MetricsTests.swift

@@ -14,7 +14,7 @@
 
 @testable import CoreMetrics
 @testable import Metrics
-@testable import MetricsTestKit
+import MetricsTestKit
 import XCTest
 
 class MetricsExtensionsTests: XCTestCase {
@@ -132,25 +132,25 @@ class MetricsExtensionsTests: XCTestCase {
         let testTimer = timer._handler as! TestTimer
 
         testTimer.preferDisplayUnit(.nanoseconds)
-        XCTAssertEqual(testTimer.retrieveValueInPreferredUnit(atIndex: 0), value * 1000 * 1000 * 1000, accuracy: 1.0, "expected value to match")
+        XCTAssertEqual(testTimer.valueInPreferredUnit(atIndex: 0), value * 1000 * 1000 * 1000, accuracy: 1.0, "expected value to match")
 
         testTimer.preferDisplayUnit(.microseconds)
-        XCTAssertEqual(testTimer.retrieveValueInPreferredUnit(atIndex: 0), value * 1000 * 1000, accuracy: 0.001, "expected value to match")
+        XCTAssertEqual(testTimer.valueInPreferredUnit(atIndex: 0), value * 1000 * 1000, accuracy: 0.001, "expected value to match")
 
         testTimer.preferDisplayUnit(.milliseconds)
-        XCTAssertEqual(testTimer.retrieveValueInPreferredUnit(atIndex: 0), value * 1000, accuracy: 0.000001, "expected value to match")
+        XCTAssertEqual(testTimer.valueInPreferredUnit(atIndex: 0), value * 1000, accuracy: 0.000001, "expected value to match")
 
         testTimer.preferDisplayUnit(.seconds)
-        XCTAssertEqual(testTimer.retrieveValueInPreferredUnit(atIndex: 0), value, accuracy: 0.000000001, "expected value to match")
+        XCTAssertEqual(testTimer.valueInPreferredUnit(atIndex: 0), value, accuracy: 0.000000001, "expected value to match")
 
         testTimer.preferDisplayUnit(.minutes)
-        XCTAssertEqual(testTimer.retrieveValueInPreferredUnit(atIndex: 0), value / 60, accuracy: 0.000000001, "expected value to match")
+        XCTAssertEqual(testTimer.valueInPreferredUnit(atIndex: 0), value / 60, accuracy: 0.000000001, "expected value to match")
 
         testTimer.preferDisplayUnit(.hours)
-        XCTAssertEqual(testTimer.retrieveValueInPreferredUnit(atIndex: 0), value / (60 * 60), accuracy: 0.000000001, "expected value to match")
+        XCTAssertEqual(testTimer.valueInPreferredUnit(atIndex: 0), value / (60 * 60), accuracy: 0.000000001, "expected value to match")
 
         testTimer.preferDisplayUnit(.days)
-        XCTAssertEqual(testTimer.retrieveValueInPreferredUnit(atIndex: 0), value / (60 * 60 * 24), accuracy: 0.000000001, "expected value to match")
+        XCTAssertEqual(testTimer.valueInPreferredUnit(atIndex: 0), value / (60 * 60 * 24), accuracy: 0.000000001, "expected value to match")
     }
 }
 

Tests/MetricsTests/TestSendable.swift

@@ -14,7 +14,7 @@
 
 @testable import CoreMetrics
 import Dispatch
-@testable import MetricsTestKit
+import MetricsTestKit
 import XCTest
 
 class SendableTest: XCTestCase {
@@ -32,7 +32,7 @@ class SendableTest: XCTestCase {
             let task = Task.detached { () -> [Int64] in
                 counter.increment(by: value)
                 let handler = counter._handler as! TestCounter
-                return handler.values.map { $0.1 }
+                return handler.values
             }
             let values = await task.value
             XCTAssertEqual(values.count, 1, "expected number of entries to match")
@@ -61,7 +61,7 @@ class SendableTest: XCTestCase {
             let task = Task.detached { () -> [Double] in
                 recorder.record(value)
                 let handler = recorder._handler as! TestRecorder
-                return handler.values.map { $0.1 }
+                return handler.values
             }
             let values = await task.value
             XCTAssertEqual(values.count, 1, "expected number of entries to match")
@@ -76,7 +76,7 @@ class SendableTest: XCTestCase {
             let task = Task.detached { () -> [Double] in
                 meter.set(value)
                 let handler = meter._handler as! TestMeter
-                return handler.values.map { $0.1 }
+                return handler.values
             }
             let values = await task.value
             XCTAssertEqual(values.count, 1, "expected number of entries to match")