react-native-queue-player 1.2.0 → 2.0.1

package/ios/Tests/ReplayGainExtractorTests.swift

@@ -36,6 +36,32 @@ final class ReplayGainExtractorTests: XCTestCase {
     XCTAssertEqual(actual, expected, accuracy: accuracy, file: file, line: line)
   }
 
+  private func assertAcceptedGain(
+    _ value: Double,
+    expected: Double,
+    accuracy: Double = 0.001,
+    file: StaticString = #file, line: UInt = #line
+  ) {
+    guard let actual = ReplayGainExtractor.acceptGainDb(value) else {
+      XCTFail("expected acceptGainDb(\(value)) to succeed", file: file, line: line)
+      return
+    }
+    XCTAssertEqual(actual, expected, accuracy: accuracy, file: file, line: line)
+  }
+
+  private func assertAcceptedPeak(
+    _ value: Double,
+    expected: Double,
+    accuracy: Double = 0.0001,
+    file: StaticString = #file, line: UInt = #line
+  ) {
+    guard let actual = ReplayGainExtractor.acceptPeak(value) else {
+      XCTFail("expected acceptPeak(\(value)) to succeed", file: file, line: line)
+      return
+    }
+    XCTAssertEqual(actual, expected, accuracy: accuracy, file: file, line: line)
+  }
+
   // MARK: - parseGainDb tolerance
 
   func testParseGainDbStandardFormat() {
@@ -94,7 +120,7 @@ final class ReplayGainExtractorTests: XCTestCase {
     XCTAssertNil(ReplayGainExtractor.parseGainDb("-inf"))
   }
 
-  // MARK: - parsePeak tolerance + encoder-default detection
+  // MARK: - parsePeak tolerance + plausible-range guards
 
   func testParsePeakStandardLinear() {
     assertPeak("0.987654", expected: 0.987654)
@@ -102,17 +128,47 @@ final class ReplayGainExtractorTests: XCTestCase {
     assertPeak("1.234567", expected: 1.234567)
   }
 
-  func testParsePeakRejectsEncoderDefaultsOneAndZero() {
-    XCTAssertNil(ReplayGainExtractor.parsePeak("1.000000"),
-                 "peak == exactly 1.0 means the analyser didn't run")
-    XCTAssertNil(ReplayGainExtractor.parsePeak("1"),
-                 "peak == exactly 1.0 means the analyser didn't run")
+  func testPeakAtFullScaleIsAccepted() {
+    // 1.000000 is the spec's encoding of digital full scale — a real
+    // measurement for a modern master, and the one most in need of the
+    // 1/peak clip cap.
+    assertPeak("1.000000", expected: 1.0)
+    assertPeak("1", expected: 1.0)
+  }
+
+  func testParsePeakRejectsEncoderZero() {
     XCTAssertNil(ReplayGainExtractor.parsePeak("0.0001"),
                  "peak < 0.001 means encoder zero / no analysis")
     XCTAssertNil(ReplayGainExtractor.parsePeak("0"),
                  "peak == 0 means encoder zero")
   }
 
+  func testParsePeakAcceptsRealMeasurementsEitherSideOfUnity() {
+    assertPeak("0.923366", expected: 0.923366)
+    assertPeak("1.160082", expected: 1.160082)
+  }
+
+  func testParsePeakAcceptsTheLowerBoundary() {
+    assertPeak("0.001", expected: 0.001, accuracy: 0.000001)
+  }
+
+  func testParsePeakRejectsJustBelowTheLowerBoundary() {
+    XCTAssertNil(ReplayGainExtractor.parsePeak("0.000999"))
+  }
+
+  func testParsePeakAcceptsTheUpperBoundary() {
+    assertPeak("2.0", expected: 2.0)
+  }
+
+  func testParsePeakRejectsJustAboveTheUpperBoundary() {
+    XCTAssertNil(ReplayGainExtractor.parsePeak("2.000001"))
+  }
+
+  func testParsePeakRejectsCommaDecimal() {
+    // RG2 is period-decimal, same as the gain path.
+    XCTAssertNil(ReplayGainExtractor.parsePeak("0,5"))
+  }
+
   func testParsePeakRejectsOutOfRange() {
     XCTAssertNil(ReplayGainExtractor.parsePeak("-0.5"))
     XCTAssertNil(ReplayGainExtractor.parsePeak("3.0"))
@@ -189,4 +245,158 @@ final class ReplayGainExtractorTests: XCTestCase {
     }
   }
 
+  // MARK: - acceptPeak — the numeric half of the same rule
+
+  func testAcceptPeakAcceptsFullScale() {
+    assertAcceptedPeak(1.0, expected: 1.0)
+  }
+
+  func testAcceptPeakAcceptsTheBoundaries() {
+    assertAcceptedPeak(0.001, expected: 0.001, accuracy: 0.000001)
+    assertAcceptedPeak(2.0, expected: 2.0)
+  }
+
+  func testAcceptPeakAcceptsRealMeasurementsEitherSideOfUnity() {
+    assertAcceptedPeak(0.923366, expected: 0.923366)
+    assertAcceptedPeak(1.160082, expected: 1.160082)
+  }
+
+  func testAcceptPeakRejectsValuesOutsideTheBoundaries() {
+    // Paired with an accepted value so the test still fails against an
+    // acceptor that rejects everything.
+    assertAcceptedPeak(0.5, expected: 0.5)
+    XCTAssertNil(ReplayGainExtractor.acceptPeak(0.000999))
+    XCTAssertNil(ReplayGainExtractor.acceptPeak(2.000001))
+    XCTAssertNil(ReplayGainExtractor.acceptPeak(0.0))
+    XCTAssertNil(ReplayGainExtractor.acceptPeak(-0.5))
+    XCTAssertNil(ReplayGainExtractor.acceptPeak(3.0))
+  }
+
+  func testAcceptPeakRejectsNonFinite() {
+    assertAcceptedPeak(1.0, expected: 1.0)
+    XCTAssertNil(ReplayGainExtractor.acceptPeak(.nan))
+    XCTAssertNil(ReplayGainExtractor.acceptPeak(.infinity))
+    XCTAssertNil(ReplayGainExtractor.acceptPeak(-.infinity))
+  }
+
+  // MARK: - acceptGainDb — the numeric half of the same rule
+
+  func testAcceptGainDbAcceptsAnyFiniteValue() {
+    assertAcceptedGain(-20.0, expected: -20.0)
+    assertAcceptedGain(-6.54, expected: -6.54)
+    assertAcceptedGain(0.0, expected: 0.0)
+    assertAcceptedGain(3.21, expected: 3.21)
+  }
+
+  func testAcceptGainDbAppliesNoRangeGuard() {
+    // Unlike a peak, a gain has no plausible-value window — the only
+    // rejection is non-finite.
+    assertAcceptedGain(100.0, expected: 100.0)
+    assertAcceptedGain(-100.0, expected: -100.0)
+  }
+
+  func testAcceptGainDbRejectsNonFinite() {
+    assertAcceptedGain(-6.0, expected: -6.0)
+    XCTAssertNil(ReplayGainExtractor.acceptGainDb(.nan))
+    XCTAssertNil(ReplayGainExtractor.acceptGainDb(.infinity))
+    XCTAssertNil(ReplayGainExtractor.acceptGainDb(-.infinity))
+  }
+
+  // MARK: - One rule, two entry points
+
+  func testPeakStringAndNumericPathsAgree() {
+    // The string parser is the numeric acceptor plus text handling, so
+    // every value that has both representations must land identically.
+    let cases: [(String, Double)] = [
+      ("1.000000", 1.0),
+      ("1", 1.0),
+      ("0.923366", 0.923366),
+      ("1.160082", 1.160082),
+      ("0.5", 0.5),
+      ("2.0", 2.0),
+      ("2.000001", 2.000001),
+      ("0.001", 0.001),
+      ("0.000999", 0.000999),
+      ("0", 0.0),
+      ("-0.5", -0.5),
+      ("3.0", 3.0),
+      ("nan", Double.nan),
+      ("inf", Double.infinity),
+      ("-inf", -Double.infinity),
+    ]
+    for (raw, value) in cases {
+      XCTAssertEqual(
+        ReplayGainExtractor.parsePeak(raw),
+        ReplayGainExtractor.acceptPeak(value),
+        "parsePeak(\"\(raw)\") and acceptPeak(\(value)) must agree"
+      )
+    }
+  }
+
+  func testGainDbStringAndNumericPathsAgree() {
+    let cases: [(String, Double)] = [
+      ("-20.00 dB", -20.0),
+      ("-6.54", -6.54),
+      ("+3.21 dB", 3.21),
+      ("0.00 dB", 0.0),
+      ("100.0", 100.0),
+      ("-100.0", -100.0),
+      ("nan dB", Double.nan),
+      ("inf", Double.infinity),
+      ("-inf", -Double.infinity),
+    ]
+    for (raw, value) in cases {
+      XCTAssertEqual(
+        ReplayGainExtractor.parseGainDb(raw),
+        ReplayGainExtractor.acceptGainDb(value),
+        "parseGainDb(\"\(raw)\") and acceptGainDb(\(value)) must agree"
+      )
+    }
+  }
+
+  // MARK: - Tag-set acceptance
+
+  // MARK: - Tag-set acceptance
+
+  func testRgDataFromTagsParsesAllFourFields() throws {
+    let data = try XCTUnwrap(ReplayGainExtractor.rgDataFromTags([
+      "REPLAYGAIN_TRACK_GAIN": "-12.0 dB",
+      "REPLAYGAIN_TRACK_PEAK": "0.95",
+      "REPLAYGAIN_ALBUM_GAIN": "-8.0 dB",
+      "REPLAYGAIN_ALBUM_PEAK": "0.90",
+    ]))
+    XCTAssertEqual(try XCTUnwrap(data.trackGainDb), -12.0, accuracy: 0.001)
+    XCTAssertEqual(try XCTUnwrap(data.trackPeak), 0.95, accuracy: 0.001)
+    XCTAssertEqual(try XCTUnwrap(data.albumGainDb), -8.0, accuracy: 0.001)
+    XCTAssertEqual(try XCTUnwrap(data.albumPeak), 0.90, accuracy: 0.001)
+  }
+
+  func testRgDataFromTagsAcceptsLowercaseKeys() throws {
+    let data = try XCTUnwrap(ReplayGainExtractor.rgDataFromTags([
+      "replaygain_track_gain": "-6.5 dB",
+    ]))
+    XCTAssertEqual(try XCTUnwrap(data.trackGainDb), -6.5, accuracy: 0.001)
+  }
+
+  func testRgDataFromTagsReturnsNilForEmptyDict() {
+    XCTAssertNil(ReplayGainExtractor.rgDataFromTags([:]))
+  }
+
+  func testRgDataFromTagsReturnsNilWhenAllValuesUnparseable() {
+    XCTAssertNil(ReplayGainExtractor.rgDataFromTags([
+      "REPLAYGAIN_TRACK_GAIN": "garbage",
+      "REPLAYGAIN_TRACK_PEAK": "3.0",  // above the plausible range → rejected
+    ]))
+  }
+
+  func testRgDataFromTagsAcceptsAFullScalePeak() throws {
+    // 1.000000 is digital full scale — a measurement, so the tag set is
+    // usable even when it carries nothing else.
+    let data = try XCTUnwrap(ReplayGainExtractor.rgDataFromTags([
+      "REPLAYGAIN_TRACK_PEAK": "1.000000",
+    ]))
+    XCTAssertEqual(try XCTUnwrap(data.trackPeak), 1.0, accuracy: 0.0001)
+  }
+
+  // MARK: - Opus container guard
 }

package/ios/Tests/ReplayGainMergeTests.swift

@@ -0,0 +1,230 @@
+import XCTest
+@testable import QueuePlayer
+
+/// Unit tests for `ReplayGainData.merge(suppliedClaimed:supplied:detected:)`
+/// — the all-or-nothing, per-item choice between consumer-supplied
+/// ReplayGain and values detected from the file.
+///
+/// The rule is one predicate on the item, not two pair decisions and not
+/// four field decisions: if the consumer supplied *any* of the four
+/// fields, that track's ReplayGain comes solely from the consumer and
+/// detection is discarded in full — including for the mode the consumer
+/// said nothing about. Supplying a value is itself the statement of
+/// intent; a consumer who wanted the file's own tags supplies nothing.
+///
+/// `suppliedClaimed` is captured before validation, so
+/// `suppliedClaimed == true` with `supplied == nil` is a real state
+/// meaning "the consumer owns this track and gave nothing usable".
+/// Ownership is triggered by field *presence*, not validity.
+///
+/// Supplied and detected fixtures deliberately carry different values in
+/// every field, so a row that returned the wrong source cannot pass.
+final class ReplayGainMergeTests: XCTestCase {
+
+  // MARK: - Fixtures
+
+  private let detectedAll = ReplayGainData(
+    trackGainDb: -20.0, trackPeak: 0.5,
+    albumGainDb: -6.0, albumPeak: 0.6
+  )
+  private let detectedTrackOnly = ReplayGainData(
+    trackGainDb: -20.0, trackPeak: 0.5,
+    albumGainDb: nil, albumPeak: nil
+  )
+  private let detectedAlbumOnly = ReplayGainData(
+    trackGainDb: nil, trackPeak: nil,
+    albumGainDb: -6.0, albumPeak: 0.6
+  )
+
+  private let suppliedAll = ReplayGainData(
+    trackGainDb: -3.0, trackPeak: 0.25,
+    albumGainDb: -9.0, albumPeak: 0.3
+  )
+  private let suppliedTrackGain = ReplayGainData(
+    trackGainDb: -3.0, trackPeak: nil,
+    albumGainDb: nil, albumPeak: nil
+  )
+  private let suppliedAlbumGain = ReplayGainData(
+    trackGainDb: nil, trackPeak: nil,
+    albumGainDb: -9.0, albumPeak: nil
+  )
+  private let suppliedTrackPeak = ReplayGainData(
+    trackGainDb: nil, trackPeak: 0.25,
+    albumGainDb: nil, albumPeak: nil
+  )
+  private let suppliedAlbumPeak = ReplayGainData(
+    trackGainDb: nil, trackPeak: nil,
+    albumGainDb: nil, albumPeak: 0.3
+  )
+  private let suppliedTrackPair = ReplayGainData(
+    trackGainDb: -3.0, trackPeak: 0.25,
+    albumGainDb: nil, albumPeak: nil
+  )
+  private let suppliedAlbumPair = ReplayGainData(
+    trackGainDb: nil, trackPeak: nil,
+    albumGainDb: -9.0, albumPeak: 0.3
+  )
+
+  // MARK: - Helper
+
+  private func assertMerge(
+    claimed: Bool,
+    supplied: ReplayGainData?,
+    detected: ReplayGainData?,
+    equals expected: ReplayGainData?,
+    _ message: String,
+    file: StaticString = #file, line: UInt = #line
+  ) {
+    let actual = ReplayGainData.merge(
+      suppliedClaimed: claimed, supplied: supplied, detected: detected
+    )
+    XCTAssertEqual(actual, expected, message, file: file, line: line)
+  }
+
+  // MARK: - No claim — detection is used verbatim
+
+  func testAnUnclaimedTrackUsesEveryDetectedField() {
+    assertMerge(
+      claimed: false, supplied: nil, detected: detectedAll,
+      equals: detectedAll,
+      "no supplied field means detection is used, all four"
+    )
+  }
+
+  func testAnUnclaimedTrackWithNoDetectionHasNoReplayGain() {
+    assertMerge(
+      claimed: false, supplied: nil, detected: nil,
+      equals: nil,
+      "nothing supplied and nothing detected is no ReplayGain"
+    )
+  }
+
+  func testAnUnclaimedTrackKeepsATrackOnlyDetection() {
+    assertMerge(
+      claimed: false, supplied: nil, detected: detectedTrackOnly,
+      equals: detectedTrackOnly,
+      "a partial detection is used as-is, not padded"
+    )
+  }
+
+  func testAnUnclaimedTrackKeepsAnAlbumOnlyDetection() {
+    assertMerge(
+      claimed: false, supplied: nil, detected: detectedAlbumOnly,
+      equals: detectedAlbumOnly,
+      "the mirrored partial-detection case"
+    )
+  }
+
+  // MARK: - Claimed — one supplied field discards all detection
+
+  func testASuppliedTrackGainDiscardsEveryDetectedField() {
+    assertMerge(
+      claimed: true, supplied: suppliedTrackGain, detected: detectedAll,
+      equals: suppliedTrackGain,
+      "supplied trackGain applies; detected peak and album pair are dropped"
+    )
+  }
+
+  func testASuppliedAlbumGainDiscardsEveryDetectedField() {
+    assertMerge(
+      claimed: true, supplied: suppliedAlbumGain, detected: detectedAll,
+      equals: suppliedAlbumGain,
+      "supplied albumGain applies; detected track pair and album peak are dropped"
+    )
+  }
+
+  func testASuppliedTrackPeakAloneLeavesNoGainAnywhere() {
+    assertMerge(
+      claimed: true, supplied: suppliedTrackPeak, detected: detectedAll,
+      equals: suppliedTrackPeak,
+      "a peak with no gain is ownership with nothing to apply"
+    )
+  }
+
+  func testASuppliedAlbumPeakAloneLeavesNoGainAnywhere() {
+    assertMerge(
+      claimed: true, supplied: suppliedAlbumPeak, detected: detectedAll,
+      equals: suppliedAlbumPeak,
+      "the mirrored peak-only case"
+    )
+  }
+
+  func testASuppliedTrackPairDiscardsTheDetectedAlbumPair() {
+    assertMerge(
+      claimed: true, supplied: suppliedTrackPair, detected: detectedAll,
+      equals: suppliedTrackPair,
+      "album mode plays at unity even though the file carries album tags"
+    )
+  }
+
+  func testASuppliedAlbumPairDiscardsTheDetectedTrackPair() {
+    assertMerge(
+      claimed: true, supplied: suppliedAlbumPair, detected: detectedAll,
+      equals: suppliedAlbumPair,
+      "track mode plays at unity even though the file carries track tags"
+    )
+  }
+
+  func testAFullySuppliedSetReplacesAFullyDetectedSet() {
+    assertMerge(
+      claimed: true, supplied: suppliedAll, detected: detectedAll,
+      equals: suppliedAll,
+      "all four supplied values win over all four detected values"
+    )
+  }
+
+  func testASuppliedTrackGainDiscardsAnAlbumOnlyDetection() {
+    assertMerge(
+      claimed: true, supplied: suppliedTrackGain, detected: detectedAlbumOnly,
+      equals: suppliedTrackGain,
+      "detection is discarded even where supplied and detected do not overlap"
+    )
+  }
+
+  // MARK: - Claimed with no detection to discard
+
+  func testAFullySuppliedSetAppliesToAnUntaggedFile() {
+    assertMerge(
+      claimed: true, supplied: suppliedAll, detected: nil,
+      equals: suppliedAll,
+      "the motivating case — a server that stripped tags on transcode"
+    )
+  }
+
+  func testASuppliedTrackGainAppliesToAnUntaggedFile() {
+    assertMerge(
+      claimed: true, supplied: suppliedTrackGain, detected: nil,
+      equals: suppliedTrackGain,
+      "a single supplied field on an untagged file applies alone"
+    )
+  }
+
+  // MARK: - Claimed but nothing usable — ownership without a value
+
+  func testAClaimWithNoUsableValueDiscardsAFullDetection() {
+    // Every supplied value was rejected by validation, so `supplied` is
+    // nil — but the claim was captured before validation, so the file's
+    // tags do not come back.
+    assertMerge(
+      claimed: true, supplied: nil, detected: detectedAll,
+      equals: nil,
+      "presence, not validity, is what claims the track"
+    )
+  }
+
+  func testAClaimWithNoUsableValueDiscardsAPartialDetection() {
+    assertMerge(
+      claimed: true, supplied: nil, detected: detectedTrackOnly,
+      equals: nil,
+      "a partial detection is discarded by a claim just as a full one is"
+    )
+  }
+
+  func testAClaimWithNoUsableValueAndNoDetectionHasNoReplayGain() {
+    assertMerge(
+      claimed: true, supplied: nil, detected: nil,
+      equals: nil,
+      "ownership claimed, nothing supplied, nothing detected"
+    )
+  }
+}