浏览代码

-Added additional tests for Image Downloader
-Fixed minor bugs

Kevin Harwood 10 年之前
父节点
当前提交
1245bde7b1

+ 4 - 0
Tests/AFNetworking Tests.xcodeproj/project.pbxproj

@@ -16,6 +16,7 @@
 		2902D29517DF4E2A00C81C5A /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 2902D29317DF4E2A00C81C5A /* InfoPlist.strings */; };
 		2902D29C17DF4E3700C81C5A /* AFTestCase.m in Sources */ = {isa = PBXBuildFile; fileRef = 29B9ED7617DF4D790021E4D5 /* AFTestCase.m */; };
 		2902D29D17DF4E3800C81C5A /* AFTestCase.m in Sources */ = {isa = PBXBuildFile; fileRef = 29B9ED7617DF4D790021E4D5 /* AFTestCase.m */; };
+		29126F201BBED75600EBF354 /* AFImageDownloaderTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 29126F1F1BBED75600EBF354 /* AFImageDownloaderTests.m */; };
 		2940C00A1B063C6700AFDAC7 /* AFUIActivityIndicatorViewTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 2940C0091B063C6700AFDAC7 /* AFUIActivityIndicatorViewTests.m */; };
 		2940C00C1B064C3200AFDAC7 /* AFUIRefreshControlTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 2940C00B1B064C3200AFDAC7 /* AFUIRefreshControlTests.m */; };
 		295B1DCD1BBD8BB100EE113D /* AFAutoPurgingImageCacheTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 295B1DCC1BBD8BB100EE113D /* AFAutoPurgingImageCacheTests.m */; };
@@ -86,6 +87,7 @@
 		2902D29217DF4E2A00C81C5A /* OS X Tests-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "OS X Tests-Info.plist"; sourceTree = "<group>"; };
 		2902D29417DF4E2A00C81C5A /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; };
 		2902D29817DF4E2A00C81C5A /* OS X Tests-Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "OS X Tests-Prefix.pch"; sourceTree = "<group>"; };
+		29126F1F1BBED75600EBF354 /* AFImageDownloaderTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = AFImageDownloaderTests.m; sourceTree = "<group>"; };
 		29133DD417DE77A5006E0493 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = System/Library/Frameworks/CoreGraphics.framework; sourceTree = SDKROOT; };
 		29133DD617DE77ED006E0493 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; };
 		29133DD817DE7829006E0493 /* Security.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Security.framework; path = System/Library/Frameworks/Security.framework; sourceTree = SDKROOT; };
@@ -273,6 +275,7 @@
 				2940C00B1B064C3200AFDAC7 /* AFUIRefreshControlTests.m */,
 				C61291631B21E27700B9475A /* AFUIImageViewTests.m */,
 				295B1DCC1BBD8BB100EE113D /* AFAutoPurgingImageCacheTests.m */,
+				29126F1F1BBED75600EBF354 /* AFImageDownloaderTests.m */,
 			);
 			path = Tests;
 			sourceTree = "<group>";
@@ -525,6 +528,7 @@
 				77D65EBC1848A03C004CA024 /* AFPropertyListResponseSerializerTests.m in Sources */,
 				2902D29C17DF4E3700C81C5A /* AFTestCase.m in Sources */,
 				F87382951948AC15000B7AFA /* AFHTTPSessionManagerTests.m in Sources */,
+				29126F201BBED75600EBF354 /* AFImageDownloaderTests.m in Sources */,
 				295B1DCD1BBD8BB100EE113D /* AFAutoPurgingImageCacheTests.m in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;

+ 144 - 30
Tests/Tests/AFImageDownloaderTests.m

@@ -25,12 +25,16 @@
 @interface AFImageDownloaderTests : XCTestCase
 @property (nonatomic, strong) NSURLRequest *pngRequest;
 @property (nonatomic, strong) NSURLRequest *jpegRequest;
+@property (nonatomic, strong) AFImageDownloader *downloader;
+@property (nonatomic, assign) NSTimeInterval timeout;
 @end
 
 @implementation AFImageDownloaderTests
 
 - (void)setUp {
     [super setUp];
+    self.timeout = 5.0;
+    self.downloader = [[AFImageDownloader alloc] init];
     [[AFImageDownloader defaultURLCache] removeAllCachedResponses];
     [[[AFImageDownloader defaultInstance] imageCache] removeAllImages];
     NSURL *pngURL = [NSURL URLWithString:@"https://httpbin.org/image/png"];
@@ -40,33 +44,35 @@
 }
 
 - (void)tearDown {
+    [self.downloader.sessionManager invalidateSessionCancelingTasks:YES];
+    self.downloader = nil;
     // Put teardown code here. This method is called after the invocation of each test method in the class.
     [super tearDown];
     self.pngRequest = nil;
 }
 
+#pragma mark - Image Download
+
 - (void)testThatImageDownloaderSingletonCanBeInitialized {
     AFImageDownloader *downloader = [AFImageDownloader defaultInstance];
     XCTAssertNotNil(downloader, @"Downloader should not be nil");
 }
 
 - (void)testThatImageDownloaderCanBeInitializedAndDeinitializedWithActiveDownloads {
-    AFImageDownloader *downloader = [[AFImageDownloader alloc] init];
-    [downloader downloadImageForURLRequest:self.pngRequest
+    [self.downloader downloadImageForURLRequest:self.pngRequest
                                    success:nil
                                    failure:nil];
-    downloader = nil;
-    XCTAssertNil(downloader, @"Downloader should be nil");
+    self.downloader = nil;
+    XCTAssertNil(self.downloader, @"Downloader should be nil");
 }
 
 - (void)testThatImageDownloaderCanDownloadImage {
-    AFImageDownloader *downloader = [[AFImageDownloader alloc] init];
     XCTestExpectation *expectation = [self expectationWithDescription:@"image download should succeed"];
 
     __block NSHTTPURLResponse *urlResponse = nil;
     __block UIImage *responseImage = nil;
     
-    [downloader
+    [self.downloader
      downloadImageForURLRequest:self.pngRequest
      success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
          urlResponse = response;
@@ -75,19 +81,18 @@
      }
      failure:nil];
 
-    [self waitForExpectationsWithTimeout:5.0 handler:nil];
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
 
     XCTAssertNotNil(urlResponse, @"HTTPURLResponse should not be nil");
     XCTAssertNotNil(responseImage, @"Response image should not be nil");
 }
 
 - (void)testThatItCanDownloadMultipleImagesSimultaneously {
-    AFImageDownloader *downloader = [[AFImageDownloader alloc] init];
     XCTestExpectation *expectation1 = [self expectationWithDescription:@"image 1 download should succeed"];
     __block NSHTTPURLResponse *urlResponse1 = nil;
     __block UIImage *responseImage1 = nil;
 
-    [downloader
+    [self.downloader
      downloadImageForURLRequest:self.pngRequest
      success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
          urlResponse1 = response;
@@ -100,7 +105,7 @@
     __block NSHTTPURLResponse *urlResponse2 = nil;
     __block UIImage *responseImage2 = nil;
 
-    [downloader
+    [self.downloader
      downloadImageForURLRequest:self.jpegRequest
      success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
          urlResponse2 = response;
@@ -109,7 +114,7 @@
      }
      failure:nil];
 
-    [self waitForExpectationsWithTimeout:30.0 handler:nil];
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
 
     XCTAssertNotNil(urlResponse1, @"HTTPURLResponse should not be nil");
     XCTAssertNotNil(responseImage1, @"Respone image should not be nil");
@@ -119,12 +124,11 @@
 }
 
 - (void)testThatSimultaneouslyRequestsForTheSameAssetReceiveSameResponse {
-    AFImageDownloader *downloader = [[AFImageDownloader alloc] init];
     XCTestExpectation *expectation1 = [self expectationWithDescription:@"image 1 download should succeed"];
     __block NSHTTPURLResponse *urlResponse1 = nil;
     __block UIImage *responseImage1 = nil;
 
-    [downloader
+    [self.downloader
      downloadImageForURLRequest:self.pngRequest
      success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
          urlResponse1 = response;
@@ -137,7 +141,7 @@
     __block NSHTTPURLResponse *urlResponse2 = nil;
     __block UIImage *responseImage2 = nil;
 
-    [downloader
+    [self.downloader
      downloadImageForURLRequest:self.pngRequest
      success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
          urlResponse2 = response;
@@ -146,40 +150,152 @@
      }
      failure:nil];
 
-    [self waitForExpectationsWithTimeout:30.0 handler:nil];
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
 
     XCTAssertEqual(urlResponse1, urlResponse2, @"responses should be equal");
     XCTAssertEqual(responseImage2, responseImage2, @"responses should be equal");
 }
 
+#pragma mark - Caching
+- (void)testThatResponseIsNilWhenReturnedFromCache {
+    XCTestExpectation *expectation1 = [self expectationWithDescription:@"image 1 download should succeed"];
+    __block NSHTTPURLResponse *urlResponse1 = nil;
+    __block UIImage *responseImage1 = nil;
+
+    [self.downloader
+     downloadImageForURLRequest:self.pngRequest
+     success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
+         urlResponse1 = response;
+         responseImage1 = responseObject;
+         [expectation1 fulfill];
+     }
+     failure:nil];
+
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
+
+    XCTestExpectation *expectation2 = [self expectationWithDescription:@"image 2 download should succeed"];
+    __block NSHTTPURLResponse *urlResponse2 = nil;
+    __block UIImage *responseImage2 = nil;
+
+    [self.downloader
+     downloadImageForURLRequest:self.pngRequest
+     success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
+         urlResponse2 = response;
+         responseImage2 = responseObject;
+         [expectation2 fulfill];
+     }
+     failure:nil];
+
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
+
+    XCTAssertNotNil(urlResponse1);
+    XCTAssertNotNil(responseImage1);
+    XCTAssertNil(urlResponse2);
+    XCTAssertEqual(responseImage1, responseImage2);
+}
+
+- (void)testThatImageDownloadReceiptIsNilForCachedImage {
+    XCTestExpectation *expectation1 = [self expectationWithDescription:@"image 1 download should succeed"];
+    AFImageDownloadReceipt *receipt1;
+    receipt1 = [self.downloader
+                downloadImageForURLRequest:self.pngRequest
+                success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
+                    [expectation1 fulfill];
+                }
+                failure:nil];
+
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
+
+    XCTestExpectation *expectation2 = [self expectationWithDescription:@"image 2 download should succeed"];
+
+    AFImageDownloadReceipt *receipt2;
+    receipt2 = [self.downloader
+                downloadImageForURLRequest:self.pngRequest
+                success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
+                    [expectation2 fulfill];
+                }
+                failure:nil];
+
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
+
+    XCTAssertNotNil(receipt1);
+    XCTAssertNil(receipt2);
+}
+
+- (void)testThatCacheIsIgnoredIfCacheIgnoredInRequest {
+    XCTestExpectation *expectation1 = [self expectationWithDescription:@"image 1 download should succeed"];
+
+    __block NSHTTPURLResponse *urlResponse1 = nil;
+    __block UIImage *responseImage1 = nil;
+    AFImageDownloadReceipt *receipt1;
+    receipt1 = [self.downloader
+                downloadImageForURLRequest:self.pngRequest
+                success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
+                    urlResponse1 = response;
+                    responseImage1 = responseObject;
+                    [expectation1 fulfill];
+                }
+                failure:nil];
+
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
+
+    XCTestExpectation *expectation2 = [self expectationWithDescription:@"image 2 download should succeed"];
+    NSMutableURLRequest *alteredRequest = [self.pngRequest mutableCopy];
+    alteredRequest.cachePolicy = NSURLRequestReloadIgnoringLocalCacheData;
+
+    AFImageDownloadReceipt *receipt2;
+    __block NSHTTPURLResponse *urlResponse2 = nil;
+    __block UIImage *responseImage2 = nil;
+    receipt2 = [self.downloader
+                downloadImageForURLRequest:alteredRequest
+                success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
+                    urlResponse2 = response;
+                    responseImage2 = responseObject;
+                    [expectation2 fulfill];
+                }
+                failure:nil];
+
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
+
+    XCTAssertNotNil(receipt1);
+    XCTAssertNotNil(receipt2);
+    XCTAssertNotEqual(receipt1, receipt2);
+
+    XCTAssertNotNil(urlResponse1);
+    XCTAssertNotNil(responseImage1);
+
+    XCTAssertNotNil(urlResponse2);
+    XCTAssertNotNil(responseImage2);
+
+    XCTAssertNotEqual(responseImage1, responseImage2);
+}
+
 #pragma mark - Cancellation
 
 - (void)testThatCancellingDownloadCallsCompletionWithCancellationError {
-    AFImageDownloader *downloader = [[AFImageDownloader alloc] init];
     AFImageDownloadReceipt *receipt;
     XCTestExpectation *expectation = [self expectationWithDescription:@"image download should fail"];
     __block NSError *responseError = nil;
-    receipt = [downloader
+    receipt = [self.downloader
                downloadImageForURLRequest:self.pngRequest
                success:nil
                failure:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, NSError * _Nonnull error) {
                    responseError = error;
                    [expectation fulfill];
                }];
-    [downloader cancelTaskForImageDownloadReceipt:receipt];
-    [self waitForExpectationsWithTimeout:5.0 handler:nil];
+    [self.downloader cancelTaskForImageDownloadReceipt:receipt];
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
 
     XCTAssertTrue(responseError.code == NSURLErrorCancelled);
     XCTAssertTrue([responseError.domain isEqualToString:NSURLErrorDomain]);
 }
 
 - (void)testThatCancellingDownloadWithMultipleResponseHandlersCancelsFirstYetAllowsSecondToComplete {
-    AFImageDownloader *downloader = [[AFImageDownloader alloc] init];
     XCTestExpectation *expectation1 = [self expectationWithDescription:@"image 1 download should succeed"];
     __block NSHTTPURLResponse *urlResponse = nil;
     __block UIImage *responseImage = nil;
 
-    [downloader
+    [self.downloader
      downloadImageForURLRequest:self.pngRequest
      success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
          urlResponse = response;
@@ -191,15 +307,15 @@
     XCTestExpectation *expectation2 = [self expectationWithDescription:@"image 2 download should fail"];
     __block NSError *responseError = nil;
     AFImageDownloadReceipt *receipt;
-    receipt = [downloader
+    receipt = [self.downloader
                downloadImageForURLRequest:self.pngRequest
                success:nil
                failure:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, NSError * _Nonnull error) {
                    responseError = error;
                    [expectation2 fulfill];
                }];
-    [downloader cancelTaskForImageDownloadReceipt:receipt];
-    [self waitForExpectationsWithTimeout:5.0 handler:nil];
+    [self.downloader cancelTaskForImageDownloadReceipt:receipt];
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
 
     XCTAssertTrue(responseError.code == NSURLErrorCancelled);
     XCTAssertTrue([responseError.domain isEqualToString:NSURLErrorDomain]);
@@ -209,34 +325,32 @@
 
 #pragma mark - Threading
 - (void)testThatItAlwaysCallsTheSuccessHandlerOnTheMainQueue {
-    AFImageDownloader *downloader = [[AFImageDownloader alloc] init];
     XCTestExpectation *expectation = [self expectationWithDescription:@"image download should succeed"];
     __block BOOL successIsOnMainThread = false;
-    [downloader
+    [self.downloader
      downloadImageForURLRequest:self.pngRequest
      success:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, UIImage * _Nonnull responseObject) {
          successIsOnMainThread = [[NSThread currentThread] isMainThread];
          [expectation fulfill];
      }
      failure:nil];
-    [self waitForExpectationsWithTimeout:10.0 handler:nil];
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
     XCTAssertTrue(successIsOnMainThread);
 }
 
 - (void)testThatItAlwaysCallsTheFailureHandlerOnTheMainQueue {
-    AFImageDownloader *downloader = [[AFImageDownloader alloc] init];
     NSURL *url = [NSURL URLWithString:@"https://httpbin.org/status/404"];
     NSURLRequest *request = [NSURLRequest requestWithURL:url];
     XCTestExpectation *expectation = [self expectationWithDescription:@"image download should fail"];
     __block BOOL failureIsOnMainThread = false;
-    [downloader
+    [self.downloader
      downloadImageForURLRequest:request
      success:nil
      failure:^(NSURLRequest * _Nonnull request, NSHTTPURLResponse * _Nullable response, NSError * _Nonnull error) {
          failureIsOnMainThread = [[NSThread currentThread] isMainThread];
          [expectation fulfill];
      }];
-    [self waitForExpectationsWithTimeout:5.0 handler:nil];
+    [self waitForExpectationsWithTimeout:self.timeout handler:nil];
     XCTAssertTrue(failureIsOnMainThread);
 }
 

+ 24 - 29
UIKit+AFNetworking/AFImageDownloader.m

@@ -160,7 +160,6 @@
 
         name = [NSString stringWithFormat:@"com.alamofire.imagedownloader.responsequeue-%@", [[NSUUID UUID] UUIDString]];
         self.responseQueue = dispatch_queue_create([name cStringUsingEncoding:NSASCIIStringEncoding], DISPATCH_QUEUE_CONCURRENT);
-
     }
 
     return self;
@@ -215,42 +214,36 @@
         // 3) Create the request and set up authentication, validation and response serialization
         NSURLSessionDataTask *createdTask;
         __weak typeof(self) weakSelf = self;
+
         createdTask = [self.sessionManager
-                       GET:request.URL.absoluteString
-                       parameters:nil
-                       success:^(NSURLSessionDataTask * _Nonnull task, id  _Nonnull responseObject) {
+                       dataTaskWithRequest:request
+                       completionHandler:^(NSURLResponse * _Nonnull response, id  _Nullable responseObject, NSError * _Nullable error) {
                            dispatch_async(self.responseQueue, ^{
                                __strong typeof(weakSelf) strongSelf = weakSelf;
                                AFImageDownloaderMergedTask *mergedTask = [strongSelf safelyRemoveMergedTaskWithIdentifier:identifier];
-                               [strongSelf.imageCache addImage:responseObject forRequest:task.originalRequest withAdditionalIdentifier:nil];
-
-                               for (AFImageDownloaderResponseHandler *handler in mergedTask.responseHandlers) {
-                                   if (handler.successBlock) {
-                                       dispatch_async(dispatch_get_main_queue(), ^{
-                                           handler.successBlock(task.originalRequest, (NSHTTPURLResponse*)task.response, responseObject);
-                                       });
+                               if (error) {
+                                   for (AFImageDownloaderResponseHandler *handler in mergedTask.responseHandlers) {
+                                       if (handler.failureBlock) {
+                                           dispatch_async(dispatch_get_main_queue(), ^{
+                                               handler.failureBlock(request, (NSHTTPURLResponse*)response, error);
+                                           });
+                                       }
                                    }
-                               }
-                               [strongSelf safelyDecrementActiveTaskCount];
-                               [strongSelf safelyStartNextTaskIfNecessary];
-                           });
-                       }
-                       failure:^(NSURLSessionDataTask * _Nonnull task, NSError * _Nonnull error) {
-                           dispatch_async(self.responseQueue, ^{
-                               __strong typeof(weakSelf) strongSelf = weakSelf;
-                               AFImageDownloaderMergedTask *mergedTask = [strongSelf safelyRemoveMergedTaskWithIdentifier:identifier];
-                               for (AFImageDownloaderResponseHandler *handler in mergedTask.responseHandlers) {
-                                   if (handler.failureBlock) {
-                                       dispatch_async(dispatch_get_main_queue(), ^{
-                                           handler.failureBlock(task.originalRequest, (NSHTTPURLResponse*)task.response, error);
-                                       });
+                               } else {
+                                   [strongSelf.imageCache addImage:responseObject forRequest:request withAdditionalIdentifier:nil];
+
+                                   for (AFImageDownloaderResponseHandler *handler in mergedTask.responseHandlers) {
+                                       if (handler.successBlock) {
+                                           dispatch_async(dispatch_get_main_queue(), ^{
+                                               handler.successBlock(request, response, responseObject);
+                                           });
+                                       }
                                    }
+                                   [strongSelf safelyDecrementActiveTaskCount];
+                                   [strongSelf safelyStartNextTaskIfNecessary];
                                }
-                               [strongSelf safelyDecrementActiveTaskCount];
-                               [strongSelf safelyStartNextTaskIfNecessary];
                            });
                        }];
-        [createdTask suspend];
 
         // 4) Store the response handler for use when the request completes
         AFImageDownloaderResponseHandler *handler = [[AFImageDownloaderResponseHandler alloc] initWithUUID:callerUUID
@@ -309,6 +302,8 @@
     __block AFImageDownloaderMergedTask *mergedTask = nil;
     dispatch_sync(self.synchronizationQueue, ^{
         mergedTask = self.mergedTasks[identifier];
+        [self.mergedTasks removeObjectForKey:identifier];
+
     });
     return mergedTask;
 }
@@ -324,7 +319,7 @@
 - (void)safelyStartNextTaskIfNecessary {
     dispatch_sync(self.synchronizationQueue, ^{
         if ([self isActiveRequestCountBelowMaximumLimit]) {
-            while (!self.queuedMergedTasks.count > 0) {
+            while (self.queuedMergedTasks.count > 0) {
                 AFImageDownloaderMergedTask *mergedTask = [self dequeueMergedTask];
                 if (mergedTask.task.state == NSURLSessionTaskStateSuspended) {
                     [self startMergedTask:mergedTask];