Fix tests and temporarily mark main actor

Sources/Extensions/CPListItem+Kingfisher.swift

@@ -178,7 +178,7 @@ extension KingfisherWrapper where Base: CPListItem {
             },
             referenceTaskIdentifierChecker: { issuedIdentifier == self.taskIdentifier },
             completionHandler: { result in
-                CallbackQueue.mainCurrentOrAsync.execute {
+                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
                     guard issuedIdentifier == self.taskIdentifier else {
                         let reason: KingfisherError.ImageSettingErrorReason
                         do {

Sources/Extensions/ImageView+Kingfisher.swift

@@ -324,7 +324,7 @@ extension KingfisherWrapper where Base: KFCrossPlatformImageView {
             progressiveImageSetter: { self.base.image = $0 },
             referenceTaskIdentifierChecker: { issuedIdentifier == self.taskIdentifier },
             completionHandler: { result in
-                CallbackQueue.mainCurrentOrAsync.execute {
+                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
                     maybeIndicator?.stopAnimatingView()
                     guard issuedIdentifier == self.taskIdentifier else {
                         let reason: KingfisherError.ImageSettingErrorReason

Sources/Extensions/NSTextAttachment+Kingfisher.swift

@@ -195,7 +195,7 @@ extension KingfisherWrapper where Base: NSTextAttachment {
             progressiveImageSetter: { self.base.image = $0 },
             referenceTaskIdentifierChecker: { issuedIdentifier == self.taskIdentifier },
             completionHandler: { result in
-                CallbackQueue.mainCurrentOrAsync.execute {
+                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
                     guard issuedIdentifier == self.taskIdentifier else {
                         let reason: KingfisherError.ImageSettingErrorReason
                         do {

Sources/Extensions/UIButton+Kingfisher.swift

@@ -141,7 +141,7 @@ extension KingfisherWrapper where Base: UIButton {
             progressiveImageSetter: { self.base.setImage($0, for: state) },
             referenceTaskIdentifierChecker: { issuedIdentifier == self.taskIdentifier(for: state) },
             completionHandler: { result in
-                CallbackQueue.mainCurrentOrAsync.execute {
+                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
                     guard issuedIdentifier == self.taskIdentifier(for: state) else {
                         let reason: KingfisherError.ImageSettingErrorReason
                         do {
@@ -294,7 +294,7 @@ extension KingfisherWrapper where Base: UIButton {
             progressiveImageSetter: { self.base.setBackgroundImage($0, for: state) },
             referenceTaskIdentifierChecker: { issuedIdentifier == self.backgroundTaskIdentifier(for: state) },
             completionHandler: { result in
-                CallbackQueue.mainCurrentOrAsync.execute {
+                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
                     guard issuedIdentifier == self.backgroundTaskIdentifier(for: state) else {
                         let reason: KingfisherError.ImageSettingErrorReason
                         do {

Sources/General/KingfisherManager.swift

@@ -235,7 +235,7 @@ public class KingfisherManager: @unchecked Sendable {
         options: KingfisherOptionsInfo? = nil,
         progressBlock: DownloadProgressBlock? = nil,
         downloadTaskUpdated: DownloadTaskUpdatedBlock? = nil,
-        completionHandler: ((Result<RetrieveImageResult, KingfisherError>) -> Void)?) -> DownloadTask?
+        completionHandler: (@Sendable (Result<RetrieveImageResult, KingfisherError>) -> Void)?) -> DownloadTask?
     {
         let options = currentDefaultOptions + (options ?? .empty)
         let info = KingfisherParsedOptionsInfo(options)
@@ -252,7 +252,7 @@ public class KingfisherManager: @unchecked Sendable {
         options: KingfisherParsedOptionsInfo,
         progressBlock: DownloadProgressBlock? = nil,
         downloadTaskUpdated: DownloadTaskUpdatedBlock? = nil,
-        completionHandler: ((Result<RetrieveImageResult, KingfisherError>) -> Void)?) -> DownloadTask?
+        completionHandler: (@Sendable (Result<RetrieveImageResult, KingfisherError>) -> Void)?) -> DownloadTask?
     {
         var info = options
         if let block = progressBlock {
@@ -272,9 +272,11 @@ public class KingfisherManager: @unchecked Sendable {
         downloadTaskUpdated: DownloadTaskUpdatedBlock? = nil,
         progressiveImageSetter: ((KFCrossPlatformImage?) -> Void)? = nil,
         referenceTaskIdentifierChecker: (() -> Bool)? = nil,
-        completionHandler: ((Result<RetrieveImageResult, KingfisherError>) -> Void)?) -> DownloadTask?
+        completionHandler: (@Sendable (Result<RetrieveImageResult, KingfisherError>) -> Void)?) -> DownloadTask?
     {
         var options = options
+        let retryStrategy = options.retryStrategy
+        
         if let provider = ImageProgressiveProvider(options: options, refresh: { image in
             guard let setter = progressiveImageSetter else {
                 return
@@ -300,17 +302,18 @@ public class KingfisherManager: @unchecked Sendable {
         let retrievingContext = RetrievingContext(options: options, originalSource: source)
         var retryContext: RetryContext?
 
-        func startNewRetrieveTask(
+        @Sendable func startNewRetrieveTask(
             with source: Source,
+            retryContext: RetryContext?,
             downloadTaskUpdated: DownloadTaskUpdatedBlock?
         ) {
             let newTask = self.retrieveImage(with: source, context: retrievingContext) { result in
-                handler(currentSource: source, result: result)
+                handler(currentSource: source, retryContext: retryContext, result: result)
             }
             downloadTaskUpdated?(newTask)
         }
 
-        func failCurrentSource(_ source: Source, with error: KingfisherError) {
+        @Sendable func failCurrentSource(_ source: Source, retryContext: RetryContext?, with error: KingfisherError) {
             // Skip alternative sources if the user cancelled it.
             guard !error.isTaskCancelled else {
                 completionHandler?(.failure(error))
@@ -320,7 +323,7 @@ public class KingfisherManager: @unchecked Sendable {
             guard !error.isLowDataModeConstrained else {
                 if let source = retrievingContext.options.lowDataModeSource {
                     retrievingContext.options.lowDataModeSource = nil
-                    startNewRetrieveTask(with: source, downloadTaskUpdated: downloadTaskUpdated)
+                    startNewRetrieveTask(with: source, retryContext: retryContext, downloadTaskUpdated: downloadTaskUpdated)
                 } else {
                     // This should not happen.
                     completionHandler?(.failure(error))
@@ -329,7 +332,7 @@ public class KingfisherManager: @unchecked Sendable {
             }
             if let nextSource = retrievingContext.popAlternativeSource() {
                 retrievingContext.appendError(error, to: source)
-                startNewRetrieveTask(with: nextSource, downloadTaskUpdated: downloadTaskUpdated)
+                startNewRetrieveTask(with: nextSource, retryContext: retryContext, downloadTaskUpdated: downloadTaskUpdated)
             } else {
                 // No other alternative source. Finish with error.
                 if retrievingContext.propagationErrors.isEmpty {
@@ -344,26 +347,28 @@ public class KingfisherManager: @unchecked Sendable {
             }
         }
 
-        func handler(currentSource: Source, result: (Result<RetrieveImageResult, KingfisherError>)) -> Void {
+        @Sendable func handler(
+            currentSource: Source,
+            retryContext: RetryContext?,
+            result: (Result<RetrieveImageResult, KingfisherError>)
+        ) -> Void {
             switch result {
             case .success:
                 completionHandler?(result)
             case .failure(let error):
-                if let retryStrategy = options.retryStrategy {
+                if let retryStrategy = retryStrategy {
                     let context = retryContext?.increaseRetryCount() ?? RetryContext(source: source, error: error)
-                    retryContext = context
-
                     retryStrategy.retry(context: context) { decision in
                         switch decision {
                         case .retry(let userInfo):
                             context.userInfo = userInfo
-                            startNewRetrieveTask(with: source, downloadTaskUpdated: downloadTaskUpdated)
+                            startNewRetrieveTask(with: source, retryContext: context, downloadTaskUpdated: downloadTaskUpdated)
                         case .stop:
-                            failCurrentSource(currentSource, with: error)
+                            failCurrentSource(currentSource, retryContext: context, with: error)
                         }
                     }
                 } else {
-                    failCurrentSource(currentSource, with: error)
+                    failCurrentSource(currentSource, retryContext: retryContext, with: error)
                 }
             }
         }
@@ -373,7 +378,7 @@ public class KingfisherManager: @unchecked Sendable {
             context: retrievingContext)
         {
             result in
-            handler(currentSource: source, result: result)
+            handler(currentSource: source, retryContext: nil, result: result)
         }
 
     }
@@ -381,7 +386,7 @@ public class KingfisherManager: @unchecked Sendable {
     private func retrieveImage(
         with source: Source,
         context: RetrievingContext,
-        completionHandler: ((Result<RetrieveImageResult, KingfisherError>) -> Void)?) -> DownloadTask?
+        completionHandler: (@Sendable (Result<RetrieveImageResult, KingfisherError>) -> Void)?) -> DownloadTask?
     {
         let options = context.options
         if options.forceRefresh {
@@ -579,7 +584,7 @@ public class KingfisherManager: @unchecked Sendable {
     func retrieveImageFromCache(
         source: Source,
         context: RetrievingContext,
-        completionHandler: ((Result<RetrieveImageResult, KingfisherError>) -> Void)?) -> Bool
+        completionHandler: (@Sendable (Result<RetrieveImageResult, KingfisherError>) -> Void)?) -> Bool
     {
         let options = context.options
         // 1. Check whether the image was already in target cache. If so, just get it.

Tests/KingfisherTests/KingfisherManagerTests.swift

@@ -463,11 +463,13 @@ class KingfisherManagerTests: XCTestCase {
     
     func testFailingProcessOnDataProviderImage() {
         let provider = SimpleImageDataProvider(cacheKey: "key") { .success(testImageData) }
-        var called = false
+        let called = ActorBox(false)
         let p = FailingProcessor()
         let options = [KingfisherOptionsInfoItem.processor(p), .processingQueue(.mainCurrentOrAsync)]
         _ = manager.retrieveImage(with: .provider(provider), options: options) { result in
-            called = true
+            Task {
+                await called.setValue(true)
+            }
             XCTAssertNotNil(result.error)
             if case .processorError(reason: .processingFailed(let processor, _)) = result.error! {
                 XCTAssertEqual(processor.identifier, p.identifier)
@@ -475,7 +477,10 @@ class KingfisherManagerTests: XCTestCase {
                 XCTFail()
             }
         }
-        XCTAssertTrue(called)
+        Task {
+            let result = await called.value
+            XCTAssertTrue(result)
+        }
     }
     
     func testCacheOriginalImageWithOriginalCache() {
@@ -587,7 +592,7 @@ class KingfisherManagerTests: XCTestCase {
         let options1: KingfisherOptionsInfo = [.processor(p1), .cacheSerializer(s), .waitForCache]
         let source = Source.network(url)
         
-        manager.retrieveImage(with: source, options: options1) { result in
+        manager.retrieveImage(with: source, options: options1) { [s] result in
             XCTAssertTrue(p1.processed)
             
             let p2 = SimpleProcessor()
@@ -787,86 +792,106 @@ class KingfisherManagerTests: XCTestCase {
         waitForExpectations(timeout: 3, handler: nil)
     }
 
-//    func testShouldApplyImageModifierWhenLoadFromDiskCache() {
-//        let exp = expectation(description: #function)
-//        let url = testURLs[0]
-//        stub(url, data: testImageData)
-//
-//        var modifierCalled = false
-//        let modifier = AnyImageModifier { image in
-//            modifierCalled = true
-//            return image.withRenderingMode(.alwaysTemplate)
-//        }
-//
-//        manager.cache.store(testImage, forKey: url.cacheKey) { _ in
-//            self.manager.cache.clearMemoryCache()
-//            self.manager.retrieveImage(with: url, options: [.imageModifier(modifier)]) { result in
-//                XCTAssertTrue(modifierCalled)
-//                XCTAssertEqual(result.value!.cacheType, .disk)
-//                XCTAssertEqual(result.value!.image.renderingMode, .alwaysTemplate)
-//                exp.fulfill()
-//            }
-//        }
-//        waitForExpectations(timeout: 3, handler: nil)
-//    }
-
-//    func testImageModifierResultShouldNotBeCached() {
-//        let exp = expectation(description: #function)
-//        let url = testURLs[0]
-//        stub(url, data: testImageData)
-//
-//        var modifierCalled = false
-//        let modifier = AnyImageModifier { image in
-//            modifierCalled = true
-//            return image.withRenderingMode(.alwaysTemplate)
-//        }
-//        manager.retrieveImage(with: url, options: [.imageModifier(modifier)]) { result in
-//            XCTAssertTrue(modifierCalled)
-//            XCTAssertEqual(result.value?.image.renderingMode, .alwaysTemplate)
-//
-//            let memoryCached = self.manager.cache.retrieveImageInMemoryCache(forKey: url.absoluteString)
-//            XCTAssertNotNil(memoryCached)
-//            XCTAssertEqual(memoryCached?.renderingMode, .automatic)
-//
-//            self.manager.cache.retrieveImageInDiskCache(forKey: url.absoluteString) { result in
-//                XCTAssertNotNil(result.value!)
-//                XCTAssertEqual(result.value??.renderingMode, .automatic)
-//
-//                exp.fulfill()
-//            }
-//        }
-//        
-//        waitForExpectations(timeout: 3, handler: nil)
-//    }
+    func testShouldApplyImageModifierWhenLoadFromDiskCache() {
+        let exp = expectation(description: #function)
+        let url = testURLs[0]
+        stub(url, data: testImageData)
+
+        let modifierCalled = ActorBox(false)
+        let modifier = AnyImageModifier { image in
+            Task {
+                await modifierCalled.setValue(true)
+            }
+            return image.withRenderingMode(.alwaysTemplate)
+        }
+
+        manager.cache.store(testImage, forKey: url.cacheKey) { _ in
+            self.manager.cache.clearMemoryCache()
+            self.manager.retrieveImage(with: url, options: [.imageModifier(modifier)]) { result in
+                XCTAssertEqual(result.value!.cacheType, .disk)
+                XCTAssertEqual(result.value!.image.renderingMode, .alwaysTemplate)
+                Task {
+                    let result = await modifierCalled.value
+                    XCTAssertTrue(result)
+                }
+                exp.fulfill()
+            }
+        }
+        waitForExpectations(timeout: 3, handler: nil)
+    }
+
+    func testImageModifierResultShouldNotBeCached() {
+        let exp = expectation(description: #function)
+        let url = testURLs[0]
+        stub(url, data: testImageData)
+
+        let modifierCalled = ActorBox(false)
+        let modifier = AnyImageModifier { image in
+            Task {
+                await modifierCalled.setValue(true)
+            }
+            return image.withRenderingMode(.alwaysTemplate)
+        }
+        manager.retrieveImage(with: url, options: [.imageModifier(modifier)]) { result in
+            XCTAssertEqual(result.value?.image.renderingMode, .alwaysTemplate)
+
+            let memoryCached = self.manager.cache.retrieveImageInMemoryCache(forKey: url.absoluteString)
+            XCTAssertNotNil(memoryCached)
+            XCTAssertEqual(memoryCached?.renderingMode, .automatic)
+
+            self.manager.cache.retrieveImageInDiskCache(forKey: url.absoluteString) { result in
+                XCTAssertNotNil(result.value!)
+                XCTAssertEqual(result.value??.renderingMode, .automatic)
+
+                Task {
+                    let result = await modifierCalled.value
+                    XCTAssertTrue(result)
+                    exp.fulfill()
+                }
+            }
+        }
+        
+        waitForExpectations(timeout: 3, handler: nil)
+    }
 
 #endif
     
     func testRetrieveWithImageProvider() {
         let provider = SimpleImageDataProvider(cacheKey: "key") { .success(testImageData) }
-        var called = false
+        let called = ActorBox(false)
         manager.defaultOptions = .empty
         _ = manager.retrieveImage(with: .provider(provider), options: [.processingQueue(.mainCurrentOrAsync)]) {
             result in
-            called = true
             XCTAssertNotNil(result.value)
             XCTAssertTrue(result.value!.image.renderEqual(to: testImage))
+            Task {
+                await called.setValue(true)
+            }
+        }
+        Task {
+            let result = await called.value
+            XCTAssertTrue(result)
         }
-        XCTAssertTrue(called)
     }
     
     func testRetrieveWithImageProviderFail() {
         let provider = SimpleImageDataProvider(cacheKey: "key") { .failure(SimpleImageDataProvider.E()) }
-        var called = false
+        let called = ActorBox(false)
         _ = manager.retrieveImage(with: .provider(provider)) { result in
-            called = true
             XCTAssertNotNil(result.error)
             if case .imageSettingError(reason: .dataProviderError(_, let error)) = result.error! {
                 XCTAssertTrue(error is SimpleImageDataProvider.E)
             } else {
                 XCTFail()
             }
+            Task {
+                await called.setValue(true)
+            }
+        }
+        Task {
+            let result = await called.value
+            XCTAssertTrue(result)
         }
-        XCTAssertTrue(called)
     }
 
     func testContextRemovingAlternativeSource() {
@@ -970,18 +995,24 @@ class KingfisherManagerTests: XCTestCase {
         let brokenURL = URL(string: "brokenurl")!
         stub(brokenURL, data: Data())
 
-        var downloadTaskUpdatedCount = 0
+        let downloadTaskUpdatedCount = ActorBox(0)
         let task = manager.retrieveImage(
           with: .network(brokenURL),
           options: [.alternativeSources([.network(url)])],
           downloadTaskUpdated: { newTask in
-            downloadTaskUpdatedCount += 1
-            XCTAssertEqual(newTask?.sessionTask?.task.currentRequest?.url, url)
+              Task {
+                  let value = await downloadTaskUpdatedCount.value + 1
+                  await downloadTaskUpdatedCount.setValue(value)
+              }
+              XCTAssertEqual(newTask?.sessionTask?.task.currentRequest?.url, url)
           })
-          {
+        {
             result in
-            XCTAssertEqual(downloadTaskUpdatedCount, 1)
-            exp.fulfill()
+            Task {
+                let result = await downloadTaskUpdatedCount.value
+                XCTAssertEqual(result, 1)
+                exp.fulfill()
+            }
         }
 
         XCTAssertEqual(task?.sessionTask?.task.currentRequest?.url, brokenURL)