lottie-ios 3.4.0 → 3.4.3

package/Sources/Public/Animation/AnimationPublic.swift

@@ -82,7 +82,6 @@ extension Animation {
     animationCache: AnimationCacheProvider? = nil)
     -> Animation?
   {
-
     /// Check cache for animation
     if
       let animationCache = animationCache,
@@ -173,14 +172,14 @@ extension Animation {
   ///
   public static func loadedFrom(
     url: URL,
+    session: URLSession = .shared,
     closure: @escaping Animation.DownloadClosure,
     animationCache: AnimationCacheProvider?)
   {
-
     if let animationCache = animationCache, let animation = animationCache.animation(forKey: url.absoluteString) {
       closure(animation)
     } else {
-      let task = URLSession.shared.dataTask(with: url) { data, _, error in
+      let task = session.dataTask(with: url) { data, _, error in
         guard error == nil, let jsonData = data else {
           DispatchQueue.main.async {
             closure(nil)
@@ -198,7 +197,6 @@ extension Animation {
             closure(nil)
           }
         }
-
       }
       task.resume()
     }

package/Sources/Public/Animation/AnimationView.swift

@@ -358,7 +358,6 @@ final public class AnimationView: AnimationViewBase {
   /// Animatable.
   public var viewportFrame: CGRect? = nil {
     didSet {
-
       // This is really ugly, but is needed to trigger a layout pass within an animation block.
       // Typically this happens automatically, when layout objects are UIView based.
       // The animation layer is a CALayer which will not implicitly grab the animation
@@ -466,7 +465,7 @@ final public class AnimationView: AnimationViewBase {
     }
 
     let context = AnimationContext(
-      playFrom: fromFrame ?? currentProgress,
+      playFrom: fromFrame ?? currentFrame,
       playTo: toFrame,
       closure: completion)
     addNewAnimationForContext(context)
@@ -490,7 +489,6 @@ final public class AnimationView: AnimationViewBase {
     loopMode: LottieLoopMode? = nil,
     completion: LottieCompletionBlock? = nil)
   {
-
     guard let animation = animation, let markers = animation.markerMap, let to = markers[toMarker] else {
       return
     }
@@ -927,7 +925,11 @@ final public class AnimationView: AnimationViewBase {
 
   // MARK: Fileprivate
 
+  /// Context describing the animation that is currently playing in this `AnimationView`
+  ///  - When non-nil, an animation is currently playing in this view. Otherwise,
+  ///    the view is paused on a specific frame.
   fileprivate var animationContext: AnimationContext?
+
   fileprivate var _activeAnimationName: String = AnimationView.animationName
   fileprivate var animationID = 0
 
@@ -943,7 +945,6 @@ final public class AnimationView: AnimationViewBase {
   }
 
   fileprivate func makeAnimationLayer(usingEngine renderingEngine: RenderingEngineOption) {
-
     /// Remove current animation if any
     removeCurrentAnimation()
 
@@ -995,6 +996,7 @@ final public class AnimationView: AnimationViewBase {
       let coreAnimationLayer = try CoreAnimationLayer(
         animation: animation,
         imageProvider: imageProvider.cachedImageProvider,
+        textProvider: textProvider,
         fontProvider: fontProvider,
         compatibilityTrackerMode: .track,
         logger: logger)
@@ -1029,6 +1031,7 @@ final public class AnimationView: AnimationViewBase {
       let coreAnimationLayer = try CoreAnimationLayer(
         animation: animation,
         imageProvider: imageProvider.cachedImageProvider,
+        textProvider: textProvider,
         fontProvider: fontProvider,
         compatibilityTrackerMode: .abort,
         logger: logger)
@@ -1131,12 +1134,18 @@ final public class AnimationView: AnimationViewBase {
   ///  - This is not necessary with the Core Animation engine, and skipping
   ///    this step lets us avoid building the animations twice (once paused
   ///    and once again playing)
+  ///  - This method should only be called immediately before setting up another
+  ///    animation -- otherwise this AnimationView could be put in an inconsistent state.
   fileprivate func removeCurrentAnimationIfNecessary() {
     switch currentRenderingEngine {
     case .mainThread:
       removeCurrentAnimation()
     case .coreAnimation, nil:
-      break
+      // We still need to remove the `animationContext`, since it should only be present
+      // when an animation is actually playing. Without this calling `removeCurrentAnimationIfNecessary()`
+      // and then setting the animation to a specific paused frame would put this
+      // `AnimationView` in an inconsistent state.
+      animationContext = nil
     }
   }
 
@@ -1203,10 +1212,19 @@ final public class AnimationView: AnimationViewBase {
 
     if let coreAnimationLayer = animationlayer as? CoreAnimationLayer {
       var animationContext = animationContext
+
+      // Core Animation doesn't natively support negative speed values,
+      // so instead we can swap `playFrom` / `playTo`
+      if animationSpeed < 0 {
+        let temp = animationContext.playFrom
+        animationContext.playFrom = animationContext.playTo
+        animationContext.playTo = temp
+      }
+
       var timingConfiguration = CoreAnimationLayer.CAMediaTimingConfiguration(
         autoreverses: loopMode.caAnimationConfiguration.autoreverses,
         repeatCount: loopMode.caAnimationConfiguration.repeatCount,
-        speed: Float(animationSpeed))
+        speed: abs(Float(animationSpeed)))
 
       // The animation should start playing from the `currentFrame`,
       // if `currentFrame` is included in the time range being played.
@@ -1227,7 +1245,11 @@ final public class AnimationView: AnimationViewBase {
         // the duration of the _first_ loop. Instead of setting `playFrom`, we just add a `timeOffset`
         // so the first loop begins at `currentTime` but all subsequent loops are the standard duration.
         default:
-          timingConfiguration.timeOffset = currentTime - animation.time(forFrame: animationContext.playFrom)
+          if animationSpeed < 0 {
+            timingConfiguration.timeOffset = animation.time(forFrame: animationContext.playFrom) - currentTime
+          } else {
+            timingConfiguration.timeOffset = currentTime - animation.time(forFrame: animationContext.playFrom)
+          }
         }
       }
 

package/Sources/Public/Animation/AnimationViewInitializers.swift

@@ -23,11 +23,12 @@ extension AnimationView {
     name: String,
     bundle: Bundle = Bundle.main,
     imageProvider: AnimationImageProvider? = nil,
-    animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache)
+    animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache,
+    configuration: LottieConfiguration = .shared)
   {
     let animation = Animation.named(name, bundle: bundle, subdirectory: nil, animationCache: animationCache)
     let provider = imageProvider ?? BundleImageProvider(bundle: bundle, searchPath: nil)
-    self.init(animation: animation, imageProvider: provider)
+    self.init(animation: animation, imageProvider: provider, configuration: configuration)
   }
 
   /// Loads a Lottie animation from a JSON file in a specific path on disk.
@@ -38,12 +39,13 @@ extension AnimationView {
   public convenience init(
     filePath: String,
     imageProvider: AnimationImageProvider? = nil,
-    animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache)
+    animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache,
+    configuration: LottieConfiguration = .shared)
   {
     let animation = Animation.filepath(filePath, animationCache: animationCache)
     let provider = imageProvider ??
       FilepathImageProvider(filepath: URL(fileURLWithPath: filePath).deletingLastPathComponent().path)
-    self.init(animation: animation, imageProvider: provider)
+    self.init(animation: animation, imageProvider: provider, configuration: configuration)
   }
 
   /// Loads a Lottie animation asynchronously from the URL
@@ -56,15 +58,14 @@ extension AnimationView {
     url: URL,
     imageProvider: AnimationImageProvider? = nil,
     closure: @escaping AnimationView.DownloadClosure,
-    animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache)
+    animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache,
+    configuration: LottieConfiguration = .shared)
   {
-
     if let animationCache = animationCache, let animation = animationCache.animation(forKey: url.absoluteString) {
-      self.init(animation: animation, imageProvider: imageProvider)
+      self.init(animation: animation, imageProvider: imageProvider, configuration: configuration)
       closure(nil)
     } else {
-
-      self.init(animation: nil, imageProvider: imageProvider)
+      self.init(animation: nil, imageProvider: imageProvider, configuration: configuration)
 
       Animation.loadedFrom(url: url, closure: { animation in
         if let animation = animation {
@@ -87,11 +88,12 @@ extension AnimationView {
     asset name: String,
     bundle: Bundle = Bundle.main,
     imageProvider: AnimationImageProvider? = nil,
-    animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache)
+    animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache,
+    configuration: LottieConfiguration = .shared)
   {
     let animation = Animation.asset(name, bundle: bundle, animationCache: animationCache)
     let provider = imageProvider ?? BundleImageProvider(bundle: bundle, searchPath: nil)
-    self.init(animation: animation, imageProvider: provider)
+    self.init(animation: animation, imageProvider: provider, configuration: configuration)
   }
 
   // MARK: Public

package/Sources/Public/DynamicProperties/ValueProviders/GradientValueProvider.swift

@@ -94,13 +94,11 @@ public final class GradientValueProvider: ValueProvider {
   private var value: [Double] = []
 
   private func value(from colors: [Color], locations: [Double]) -> [Double] {
-
     var colorValues = [Double]()
     var alphaValues = [Double]()
     var shouldAddAlphaValues = false
 
     for i in 0..<colors.count {
-
       if colors[i].a < 1 { shouldAddAlphaValues = true }
 
       let location = locations.count > i

package/Sources/Public/FontProvider/AnimationFontProvider.swift

@@ -25,7 +25,7 @@ public final class DefaultFontProvider: AnimationFontProvider {
 
   // MARK: Lifecycle
 
-  public init() {}
+  public init() { }
 
   // MARK: Public
 

package/Sources/Public/Logging/LottieLogger.swift

@@ -10,8 +10,19 @@ public final class LottieLogger {
   // MARK: Lifecycle
 
   public init(
-    assert: @escaping Assert = Swift.assert,
-    assertionFailure: @escaping AssertionFailure = Swift.assertionFailure,
+    assert: @escaping Assert = { condition, message, file, line in
+      // If we default to `Swift.assert` directly with `assert: Assert = Swift.assert`,
+      // the call will unexpectedly not respect the -O flag and will crash in release
+      // https://github.com/apple/swift/issues/60249
+      Swift.assert(condition(), message(), file: file, line: line)
+    },
+    assertionFailure: @escaping AssertionFailure = { message, file, line in
+      // If we default to `Swift.assertionFailure` directly with
+      // `assertionFailure: AssertionFailure = Swift.assertionFailure`,
+      // the call will unexpectedly not respect the -O flag and will crash in release
+      // https://github.com/apple/swift/issues/60249
+      Swift.assertionFailure(message(), file: file, line: line)
+    },
     warn: @escaping Warn = { message, _, _ in
       #if DEBUG
       // swiftlint:disable:next no_direct_standard_out_logs
@@ -114,10 +125,12 @@ extension LottieLogger {
     LottieLogger(
       assert: { condition, message, _, _ in
         if !condition() {
+          // swiftlint:disable:next no_direct_standard_out_logs
           print(message())
         }
       },
       assertionFailure: { message, _, _ in
+        // swiftlint:disable:next no_direct_standard_out_logs
         print(message())
       })
   }

package/Sources/Public/TextProvider/AnimationTextProvider.swift

@@ -43,7 +43,7 @@ public final class DefaultTextProvider: AnimationTextProvider {
 
   // MARK: Lifecycle
 
-  public init() {}
+  public init() { }
 
   // MARK: Public
 

package/Sources/Public/iOS/AnimatedButton.swift

@@ -18,20 +18,26 @@ open class AnimatedButton: AnimatedControl {
     configuration: LottieConfiguration = .shared)
   {
     super.init(animation: animation, configuration: configuration)
-    accessibilityTraits = UIAccessibilityTraits.button
+    isAccessibilityElement = true
   }
 
   public override init() {
     super.init()
-    accessibilityTraits = UIAccessibilityTraits.button
+    isAccessibilityElement = true
   }
 
   required public init?(coder aDecoder: NSCoder) {
     super.init(coder: aDecoder)
+    isAccessibilityElement = true
   }
 
   // MARK: Public
 
+  public override var accessibilityTraits: UIAccessibilityTraits {
+    set { super.accessibilityTraits = newValue }
+    get { super.accessibilityTraits.union(.button) }
+  }
+
   /// Sets the play range for the given UIControlEvent.
   public func setPlayRange(fromProgress: AnimationProgressTime, toProgress: AnimationProgressTime, event: UIControl.Event) {
     rangesForEvents[event.rawValue] = (from: fromProgress, to: toProgress)
@@ -70,9 +76,9 @@ open class AnimatedButton: AnimatedControl {
     }
   }
 
-  // MARK: Fileprivate
+  // MARK: Private
 
-  fileprivate var rangesForEvents: [UInt : (from: CGFloat, to: CGFloat)] =
+  private var rangesForEvents: [UInt : (from: CGFloat, to: CGFloat)] =
     [UIControl.Event.touchUpInside.rawValue : (from: 0, to: 1)]
 }
 #endif

package/Sources/Public/iOS/AnimatedControl.swift

@@ -100,9 +100,7 @@ open class AnimatedControl: UIControl {
     super.cancelTracking(with: event)
   }
 
-  open func animationDidSet() {
-
-  }
+  open func animationDidSet() { }
 
   // MARK: Public
 
@@ -158,9 +156,9 @@ open class AnimatedControl: UIControl {
     }
   }
 
-  // MARK: Fileprivate
+  // MARK: Private
 
-  fileprivate func commonInit() {
+  private func commonInit() {
     animationView.clipsToBounds = false
     clipsToBounds = true
     animationView.translatesAutoresizingMaskIntoConstraints = false

package/Sources/Public/iOS/AnimatedSwitch.swift

@@ -32,8 +32,8 @@ open class AnimatedSwitch: AnimatedControl {
     hapticGenerator = NullHapticGenerator()
     #endif
     super.init(animation: animation, configuration: configuration)
+    isAccessibilityElement = true
     updateOnState(isOn: _isOn, animated: false, shouldFireHaptics: false)
-    accessibilityTraits = UIAccessibilityTraits.button
   }
 
   public override init() {
@@ -48,8 +48,8 @@ open class AnimatedSwitch: AnimatedControl {
     hapticGenerator = NullHapticGenerator()
     #endif
     super.init()
+    isAccessibilityElement = true
     updateOnState(isOn: _isOn, animated: false, shouldFireHaptics: false)
-    accessibilityTraits = UIAccessibilityTraits.button
   }
 
   required public init?(coder aDecoder: NSCoder) {
@@ -64,7 +64,7 @@ open class AnimatedSwitch: AnimatedControl {
     hapticGenerator = NullHapticGenerator()
     #endif
     super.init(coder: aDecoder)
-    accessibilityTraits = UIAccessibilityTraits.button
+    isAccessibilityElement = true
   }
 
   // MARK: Public
@@ -79,6 +79,11 @@ open class AnimatedSwitch: AnimatedControl {
   /// The cancel behavior for the switch. See CancelBehavior for options
   public var cancelBehavior: CancelBehavior = .reverse
 
+  public override var accessibilityTraits: UIAccessibilityTraits {
+    set { super.accessibilityTraits = newValue }
+    get { super.accessibilityTraits.union(.button) }
+  }
+
   /// The current state of the switch.
   public var isOn: Bool {
     set {
@@ -203,9 +208,7 @@ protocol ImpactGenerator {
 // MARK: - NullHapticGenerator
 
 class NullHapticGenerator: ImpactGenerator {
-  func generateImpact() {
-
-  }
+  func generateImpact() { }
 }
 
 #if os(iOS)

package/Sources/Public/iOS/BundleImageProvider.swift

@@ -32,7 +32,6 @@ public class BundleImageProvider: AnimationImageProvider {
   // MARK: Public
 
   public func imageForAsset(asset: ImageAsset) -> CGImage? {
-
     if
       let data = Data(imageAsset: asset),
       let image = UIImage(data: data)
@@ -68,7 +67,7 @@ public class BundleImageProvider: AnimationImageProvider {
 
     if imagePath == nil {
       guard let image = UIImage(named: asset.name, in: bundle, compatibleWith: nil) else {
-        LottieLogger.shared.assertionFailure("Could not find image \"\(asset.name)\" in bundle")
+        LottieLogger.shared.warn("Could not find image \"\(asset.name)\" in bundle")
         return nil
       }
       return image.cgImage
@@ -76,7 +75,7 @@ public class BundleImageProvider: AnimationImageProvider {
 
     guard let foundPath = imagePath, let image = UIImage(contentsOfFile: foundPath) else {
       /// No image found.
-      LottieLogger.shared.assertionFailure("Could not find image \"\(asset.name)\" in bundle")
+      LottieLogger.shared.warn("Could not find image \"\(asset.name)\" in bundle")
       return nil
     }
     return image.cgImage

package/Sources/Public/iOS/FilepathImageProvider.swift

@@ -29,7 +29,6 @@ public class FilepathImageProvider: AnimationImageProvider {
   // MARK: Public
 
   public func imageForAsset(asset: ImageAsset) -> CGImage? {
-
     if
       asset.name.hasPrefix("data:"),
       let url = URL(string: asset.name),
@@ -49,7 +48,7 @@ public class FilepathImageProvider: AnimationImageProvider {
       return UIImage(contentsOfFile: pathWithDirectory)?.cgImage
     }
 
-    LottieLogger.shared.assertionFailure("Could not find image \"\(asset.name)\" in bundle")
+    LottieLogger.shared.warn("Could not find image \"\(asset.name)\" in bundle")
     return nil
   }
 

package/Sources/Public/macOS/BundleImageProvider.macOS.swift

@@ -29,7 +29,6 @@ public class BundleImageProvider: AnimationImageProvider {
   // MARK: Public
 
   public func imageForAsset(asset: ImageAsset) -> CGImage? {
-
     if
       let data = Data(imageAsset: asset),
       let image = NSImage(data: data)
@@ -65,7 +64,7 @@ public class BundleImageProvider: AnimationImageProvider {
 
     guard let foundPath = imagePath, let image = NSImage(contentsOfFile: foundPath) else {
       /// No image found.
-      LottieLogger.shared.assertionFailure("Could not find image \"\(asset.name)\" in bundle")
+      LottieLogger.shared.warn("Could not find image \"\(asset.name)\" in bundle")
       return nil
     }
     return image.lottie_CGImage

package/Sources/Public/macOS/FilepathImageProvider.macOS.swift

@@ -28,7 +28,6 @@ public class FilepathImageProvider: AnimationImageProvider {
   // MARK: Public
 
   public func imageForAsset(asset: ImageAsset) -> CGImage? {
-
     if
       asset.name.hasPrefix("data:"),
       let url = URL(string: asset.name),
@@ -40,7 +39,6 @@ public class FilepathImageProvider: AnimationImageProvider {
 
     let directPath = filepath.appendingPathComponent(asset.name).path
     if FileManager.default.fileExists(atPath: directPath) {
-
       return NSImage(contentsOfFile: directPath)?.lottie_CGImage
     }
 
@@ -49,7 +47,7 @@ public class FilepathImageProvider: AnimationImageProvider {
       return NSImage(contentsOfFile: pathWithDirectory)?.lottie_CGImage
     }
 
-    LottieLogger.shared.assertionFailure("Could not find image \"\(asset.name)\" in bundle")
+    LottieLogger.shared.warn("Could not find image \"\(asset.name)\" in bundle")
     return nil
   }
 

package/Tests/AnimationKeypathTests.swift

@@ -49,6 +49,10 @@ final class AnimationKeypathTests: XCTestCase {
     snapshotHierarchyKeypaths(
       animationName: "Switch",
       configuration: LottieConfiguration(renderingEngine: .coreAnimation))
+
+    snapshotHierarchyKeypaths(
+      animationName: "Issues/issue_1664",
+      configuration: LottieConfiguration(renderingEngine: .coreAnimation))
   }
 
   /// The Core Animation engine supports a subset of the keypaths supported by the Main Thread engine.
@@ -58,7 +62,12 @@ final class AnimationKeypathTests: XCTestCase {
     let coreAnimationKeypaths = hierarchyKeypaths(animationName: "Switch", configuration: .init(renderingEngine: .coreAnimation))
 
     for coreAnimationKeypath in coreAnimationKeypaths {
-      XCTAssert(mainThreadKeypaths.contains(coreAnimationKeypath))
+      XCTAssert(
+        mainThreadKeypaths.contains(coreAnimationKeypath),
+        """
+        \(coreAnimationKeypath) from Core Animation rendering engine \
+        is not supported in Main Thread rendering engine
+        """)
     }
   }
 

package/Tests/AutomaticEngineTests.swift

@@ -19,6 +19,7 @@ final class AutomaticEngineTests: XCTestCase {
       let animationLayer = try XCTUnwrap(CoreAnimationLayer(
         animation: animation,
         imageProvider: BundleImageProvider(bundle: Bundle.main, searchPath: nil),
+        textProvider: DefaultTextProvider(),
         fontProvider: DefaultFontProvider(),
         compatibilityTrackerMode: .track,
         logger: .shared))

package/Tests/ParsingTests.swift

@@ -33,7 +33,8 @@ func XCTAssertNoDiff<T>(
   _ expected: @autoclosure () throws -> T,
   _ received: @autoclosure () throws -> T,
   file: StaticString = #filePath,
-  line: UInt = #line) rethrows {
+  line: UInt = #line) rethrows
+{
   let expected = try expected()
   let received = try received()
   let diff = diff(expected, received)

package/Tests/PerformanceTests.swift

@@ -50,7 +50,7 @@ final class PerformanceTests: XCTestCase {
 
     // The automatic engine option should have the same performance as the core animation engine,
     // when rendering an animation supported by the CA engine.
-    XCTAssertEqual(ratio, 1.0, accuracy: 0.2)
+    XCTAssertEqual(ratio, 1.0, accuracy: 0.5)
   }
 
   func testAnimationViewScrubbing_simpleAnimation() {
@@ -66,7 +66,7 @@ final class PerformanceTests: XCTestCase {
   func testParsing_simpleAnimation() throws {
     let data = try XCTUnwrap(Bundle.module.getAnimationData("loading_dots_1", subdirectory: "Samples/LottieFiles"))
     let ratio = try compareDeserializationPerformance(data: data, iterations: 2000)
-    XCTAssertEqual(ratio, 2, accuracy: 0.55)
+    XCTAssertEqual(ratio, 2, accuracy: 0.65)
   }
 
   func testParsing_complexAnimation() throws {
@@ -106,41 +106,40 @@ final class PerformanceTests: XCTestCase {
   {
     let engineAPerformance = measurePerformance {
       for _ in 0..<iterations {
-        // Each animation setup needs to be wrapped in its own `CATransaction`
-        // in order for the layers to be deallocated immediately. Otherwise
-        // the layers aren't deallocated until the end of the test run,
-        // which causes memory usage to grow unbounded.
-        CATransaction.begin()
-        let animationView = setupAnimationView(with: animation, configuration: .init(renderingEngine: engineA))
-        // Call `display()` on the layer to make sure any pending setup occurs immediately
-        animationView.animationLayer!.display()
-        CATransaction.commit()
+        setUpAndTearDownAnimationView(with: animation, configuration: .init(renderingEngine: engineA))
       }
     }
 
-    print("\(engineA) engine took \(engineAPerformance) seconds")
+    LottieLogger.shared.info("\(engineA) engine took \(engineAPerformance) seconds")
 
     let engineBPerformance = measurePerformance {
       for _ in 0..<iterations {
-        // Each animation setup needs to be wrapped in its own `CATransaction`
-        // in order for the layers to be deallocated immediately. Otherwise
-        // the layers aren't deallocated until the end of the test run,
-        // which causes memory usage to grow unbounded.
-        CATransaction.begin()
-        let animationView = setupAnimationView(with: animation, configuration: .init(renderingEngine: engineB))
-        // Call `display()` on the layer to make sure any pending setup occurs immediately
-        animationView.animationLayer!.display()
-        CATransaction.commit()
+        setUpAndTearDownAnimationView(with: animation, configuration: .init(renderingEngine: engineB))
       }
     }
 
-    print("\(engineB) engine took \(engineBPerformance) seconds")
+    LottieLogger.shared.info("\(engineB) engine took \(engineBPerformance) seconds")
 
     let ratio = engineBPerformance / engineAPerformance
-    print("\(engineB) engine took \(ratio)x as long as \(engineA) engine")
+    LottieLogger.shared.info("\(engineB) engine took \(ratio)x as long as \(engineA) engine")
     return ratio
   }
 
+  private func setUpAndTearDownAnimationView(with animation: Animation, configuration: LottieConfiguration) {
+    // Each animation setup needs to be wrapped in its own `CATransaction`
+    // in order for the layers to be deallocated immediately. Otherwise
+    // the layers aren't deallocated until the end of the test run,
+    // which causes memory usage to grow unbounded.
+    CATransaction.begin()
+    let animationView = setupAnimationView(with: animation, configuration: configuration)
+    // Call `display()` on the layer to make sure any pending setup occurs immediately
+    animationView.animationLayer!.display()
+    CATransaction.commit()
+
+    /// The view / layer is deallocated when the transaction is flushed
+    CATransaction.flush()
+  }
+
   /// Compares performance of scrubbing the given animation with both the Main Thread and Core Animation engine,
   /// and returns the ratio of how much slower the Core Animation is than the Main Thread engine
   private func compareEngineScrubbingPerformance(for animation: Animation, iterations: Int) -> Double {
@@ -156,7 +155,7 @@ final class PerformanceTests: XCTestCase {
       }
     }
 
-    print("Main thread engine took \(mainThreadEnginePerformance) seconds")
+    LottieLogger.shared.info("Main thread engine took \(mainThreadEnginePerformance) seconds")
 
     let coreAnimationView = setupAnimationView(with: animation, configuration: .init(renderingEngine: .coreAnimation))
     let coreAnimationEnginePerformance = measurePerformance {
@@ -168,10 +167,10 @@ final class PerformanceTests: XCTestCase {
       }
     }
 
-    print("Core Animation engine took \(coreAnimationEnginePerformance) seconds")
+    LottieLogger.shared.info("Core Animation engine took \(coreAnimationEnginePerformance) seconds")
 
     let ratio = coreAnimationEnginePerformance / mainThreadEnginePerformance
-    print("Core Animation engine took \(ratio)x as long as the Main Thread engine")
+    LottieLogger.shared.info("Core Animation engine took \(ratio)x as long as the Main Thread engine")
     return ratio
   }
 
@@ -182,7 +181,7 @@ final class PerformanceTests: XCTestCase {
       }
     }
 
-    print("Codable deserialization took \(codablePerformance) seconds")
+    LottieLogger.shared.info("Codable deserialization took \(codablePerformance) seconds")
 
     let dictPerformance = try measurePerformance {
       for _ in 0..<iterations {
@@ -190,9 +189,9 @@ final class PerformanceTests: XCTestCase {
       }
     }
 
-    print("DictionaryBased deserialization took \(dictPerformance) seconds")
+    LottieLogger.shared.info("DictionaryBased deserialization took \(dictPerformance) seconds")
     let ratio = codablePerformance / dictPerformance
-    print("Codable deserialization took \(ratio)x as long as DictionaryBased")
+    LottieLogger.shared.info("Codable deserialization took \(ratio)x as long as DictionaryBased")
     return ratio
   }