fixes #830, #880: bring back iOS functional tests

1 files changed, 178 insertions, 111 deletions

diff --git a/test/ios/MapViewTests.m b/test/ios/MapViewTests.m
index adf3aeba06..deed521b71 100644
--- a/test/ios/MapViewTests.m
+++ b/test/ios/MapViewTests.m
@@ -1,9 +1,11 @@
-#import "MapViewTests.h"
+#import <KIF/KIF.h>
 #import <KIF/KIFTestStepValidation.h>
+
 #import "KIFTestActor+MapboxGL.h"
-#import "MGLMapView.h"
 
-@interface MapViewTests () <MGLMapViewDelegate>
+#import "MapboxGL.h"
+
+@interface MapViewTests : KIFTestCase <MGLMapViewDelegate>
 
 @end
 
@@ -11,120 +13,132 @@
 
 - (void)beforeEach {
     [system simulateDeviceRotationToOrientation:UIDeviceOrientationPortrait];
-    tester.mapView.viewControllerForLayoutGuides = tester.viewController;
+
     tester.mapView.centerCoordinate = CLLocationCoordinate2DMake(38.913175, -77.032458);
     tester.mapView.zoomLevel = 14;
     tester.mapView.direction = 0;
+
     tester.mapView.zoomEnabled = YES;
     tester.mapView.scrollEnabled = YES;
     tester.mapView.rotateEnabled = YES;
+
     tester.viewController.navigationController.navigationBarHidden = YES;
     tester.viewController.navigationController.toolbarHidden = YES;
+
     tester.mapView.delegate = self;
 }
 
 - (void)testDirectionSet {
     tester.mapView.direction = 270;
-    __KIFAssertEqual(tester.mapView.direction,
-                     270,
-                     @"setting direction should take effect");
+
+    XCTAssertEqual(tester.mapView.direction,
+                   270,
+                   @"setting direction should take effect");
 
     [tester waitForTimeInterval:1];
 
-    __KIFAssertEqual(tester.compass.alpha,
-                     1,
-                     @"compass should be visible when map is rotated");
-    __KIFAssertEqualObjects([NSValue valueWithCGAffineTransform:tester.compass.transform],
-                            [NSValue valueWithCGAffineTransform:CGAffineTransformMakeRotation(M_PI * 1.5)],
-                            @"compass rotation should indicate map rotation");
+    XCTAssertEqual(tester.compass.alpha,
+                   1,
+                   @"compass should be visible when map is rotated");
+
+    XCTAssertEqualObjects([NSValue valueWithCGAffineTransform:tester.compass.transform],
+                          [NSValue valueWithCGAffineTransform:CGAffineTransformMakeRotation(M_PI * 1.5)],
+                          @"compass rotation should indicate map rotation");
 }
 
 - (void)testCompassTap {
     tester.mapView.direction = 180;
-    __KIFAssertEqual(tester.mapView.direction,
-                     180,
-                     @"setting direction should take effect");
 
-    [tester waitForTimeInterval:1];
+    XCTAssertEqual(tester.mapView.direction,
+                   180,
+                   @"setting direction should take effect");
 
     [tester.compass tap];
 
     [tester waitForTimeInterval:1];
 
-    __KIFAssertEqual(tester.mapView.direction,
-                     0,
-                     @"tapping compass should reset map direction");
-    __KIFAssertEqual(tester.compass.alpha,
-                     0,
-                     @"compass should not be visible when map is unrotated");
-    __KIFAssertEqualObjects([NSValue valueWithCGAffineTransform:tester.compass.transform],
-                            [NSValue valueWithCGAffineTransform:CGAffineTransformIdentity],
-                            @"compass rotation should indicate map rotation");
+    XCTAssertEqual(tester.mapView.direction,
+                   0,
+                   @"tapping compass should reset map direction");
+
+    XCTAssertEqual(tester.compass.alpha,
+                   0,
+                   @"compass should not be visible when map is unrotated");
+
+    XCTAssertEqualObjects([NSValue valueWithCGAffineTransform:tester.compass.transform],
+                          [NSValue valueWithCGAffineTransform:CGAffineTransformIdentity],
+                          @"compass rotation should indicate map rotation");
 }
 
 - (void)testDirectionReset {
-    tester.mapView.direction = 100;
-    __KIFAssertEqual(tester.mapView.direction,
-                     100,
-                     @"setting direction should take effect");
+    tester.mapView.direction = 90;
+
+    XCTAssertEqual(tester.mapView.direction,
+                   90,
+                   @"setting direction should take effect");
 
     [tester.mapView resetNorth];
 
     [tester waitForTimeInterval:1];
 
-    __KIFAssertEqual(tester.mapView.direction,
-                     0,
-                     @"resetting north should reset map direction");
-    __KIFAssertEqual(tester.compass.alpha,
-                     0,
-                     @"compass should not be visible when map is unrotated");
-    __KIFAssertEqualObjects([NSValue valueWithCGAffineTransform:tester.compass.transform],
-                            [NSValue valueWithCGAffineTransform:CGAffineTransformIdentity],
-                            @"compass rotation should indicate map rotation");
+    XCTAssertEqual(tester.mapView.direction,
+                   0,
+                   @"resetting north should reset map direction");
+
+    XCTAssertEqual(tester.compass.alpha,
+                   0,
+                   @"compass should not be visible when map is unrotated");
+
+    XCTAssertEqualObjects([NSValue valueWithCGAffineTransform:tester.compass.transform],
+                          [NSValue valueWithCGAffineTransform:CGAffineTransformIdentity],
+                          @"compass rotation should indicate map rotation");
 }
 
 - (void)testZoom {
     double zoom = tester.mapView.zoomLevel;
 
-    [tester.mapView zoomAtPoint:CGPointMake(tester.mapView.bounds.size.width / 2,
+    [tester.mapView zoomAtPoint:CGPointMake(tester.mapView.bounds.size.width  / 2,
                                             tester.mapView.bounds.size.height / 2)
                        distance:50
                           steps:10];
 
-    XCTAssertTrue(tester.mapView.zoomLevel > zoom,
-                  @"zoom gesture should increase zoom level");
+    XCTAssertGreaterThan(tester.mapView.zoomLevel,
+                         zoom,
+                         @"zoom gesture should increase zoom level");
 
     zoom = tester.mapView.zoomLevel;
-    [tester.mapView pinchAtPoint:CGPointMake(tester.mapView.bounds.size.width / 2,
+
+    [tester.mapView pinchAtPoint:CGPointMake(tester.mapView.bounds.size.width  / 2,
                                              tester.mapView.bounds.size.height / 2)
                         distance:50
                            steps:10];
 
-    XCTAssertTrue(tester.mapView.zoomLevel < zoom,
-                  @"pinch gesture should decrease zoom level");
+    XCTAssertLessThan(tester.mapView.zoomLevel,
+                      zoom,
+                      @"pinch gesture should decrease zoom level");
 }
 
 - (void)testZoomDisabled {
     tester.mapView.zoomEnabled = NO;
     double zoom = tester.mapView.zoomLevel;
 
-    [tester.mapView zoomAtPoint:CGPointMake(tester.mapView.bounds.size.width / 2,
+    [tester.mapView zoomAtPoint:CGPointMake(tester.mapView.bounds.size.width  / 2,
                                             tester.mapView.bounds.size.height / 2)
                        distance:50
                           steps:10];
 
-    __KIFAssertEqual(tester.mapView.zoomLevel,
-                     zoom,
-                     @"disabling zoom gesture should disallow zooming");
+    XCTAssertEqual(tester.mapView.zoomLevel,
+                   zoom,
+                   @"disabling zoom gesture should disallow zooming");
 
-    [tester.mapView pinchAtPoint:CGPointMake(tester.mapView.bounds.size.width / 2,
-                                            tester.mapView.bounds.size.height / 2)
+    [tester.mapView pinchAtPoint:CGPointMake(tester.mapView.bounds.size.width  / 2,
+                                             tester.mapView.bounds.size.height / 2)
                         distance:50
                            steps:10];
 
-    __KIFAssertEqual(tester.mapView.zoomLevel,
-                     zoom,
-                     @"disabling zoom gesture should disallow pinching");
+    XCTAssertEqual(tester.mapView.zoomLevel,
+                   zoom,
+                   @"disabling zoom gesture should disallow pinching");
 }
 
 - (void)testPan {
@@ -132,10 +146,13 @@
 
     [tester.mapView dragFromPoint:CGPointMake(10, 10) toPoint:CGPointMake(300, 300) steps:10];
 
-    XCTAssertTrue(tester.mapView.centerCoordinate.latitude > centerCoordinate.latitude,
-                  @"panning map down should increase center latitude");
-    XCTAssertTrue(tester.mapView.centerCoordinate.longitude < centerCoordinate.longitude,
-                  @"panning map right should decrease center longitude");
+    XCTAssertGreaterThan(tester.mapView.centerCoordinate.latitude,
+                         centerCoordinate.latitude,
+                         @"panning map down should increase center latitude");
+
+    XCTAssertLessThan(tester.mapView.centerCoordinate.longitude,
+                      centerCoordinate.longitude,
+                      @"panning map right should decrease center longitude");
 }
 
 - (void)testPanDisabled {
@@ -144,42 +161,82 @@
 
     [tester.mapView dragFromPoint:CGPointMake(10, 10) toPoint:CGPointMake(300, 300) steps:10];
 
-    __KIFAssertEqual(centerCoordinate.latitude,
-                     tester.mapView.centerCoordinate.latitude,
-                     @"disabling pan gesture should disallow vertical panning");
-    __KIFAssertEqual(centerCoordinate.longitude,
-                     tester.mapView.centerCoordinate.longitude,
-                     @"disabling pan gesture should disallow horizontal panning");
+    XCTAssertEqualWithAccuracy(centerCoordinate.latitude,
+                               tester.mapView.centerCoordinate.latitude,
+                               0.005,
+                               @"disabling pan gesture should disallow vertical panning");
+
+    XCTAssertEqualWithAccuracy(centerCoordinate.longitude,
+                               tester.mapView.centerCoordinate.longitude,
+                               0.005,
+                               @"disabling pan gesture should disallow horizontal panning");
+}
+
+- (void)testRotate {
+    CLLocationDirection startAngle = tester.mapView.direction;
+
+    XCTAssertNotEqual(startAngle,
+                      45,
+                      @"start angle must not be destination angle");
+
+    [tester.mapView twoFingerRotateAtPoint:tester.mapView.center angle:45];
+
+    XCTAssertGreaterThanOrEqual(fabs(tester.mapView.direction - startAngle),
+                                20,
+                                @"rotating map should change angle");
+}
+
+- (void)testRotateDisabled {
+    tester.mapView.rotateEnabled = NO;
+    CLLocationDirection startAngle = tester.mapView.direction;
+
+    XCTAssertNotEqual(startAngle,
+                      45,
+                      @"start angle must not be destination angle");
+
+    [tester.mapView twoFingerRotateAtPoint:tester.mapView.center angle:45];
+
+    XCTAssertEqualWithAccuracy(tester.mapView.direction,
+                               startAngle,
+                               0.005,
+                               @"disabling rotation show disallow rotation gestures");
 }
 
 - (void)testCenterSet {
     CLLocationCoordinate2D newCenterCoordinate = CLLocationCoordinate2DMake(45.23237263, -122.23287129);
+
     XCTAssertNotEqual(tester.mapView.centerCoordinate.latitude,
                       newCenterCoordinate.latitude,
                       @"initial setup should have differing center latitude");
+
     XCTAssertNotEqual(tester.mapView.centerCoordinate.longitude,
                       newCenterCoordinate.longitude,
                       @"initial setup should have differing center longitude");
 
-    [tester.mapView setCenterCoordinate:newCenterCoordinate];
+    tester.mapView.centerCoordinate = newCenterCoordinate;
+
+    XCTAssertEqual(tester.mapView.centerCoordinate.latitude,
+                   newCenterCoordinate.latitude,
+                   @"setting center should change latitude");
 
-    XCTAssertTrue(tester.mapView.centerCoordinate.latitude == newCenterCoordinate.latitude,
-                  @"setting center should change latitude");
-    XCTAssertTrue(tester.mapView.centerCoordinate.longitude == newCenterCoordinate.longitude,
-                  @"setting center should change longitude");
+    XCTAssertEqual(tester.mapView.centerCoordinate.longitude,
+                   newCenterCoordinate.longitude,
+                   @"setting center should change longitude");
 }
 
 - (void)testZoomSet {
     double newZoom = 11.65;
+
     XCTAssertNotEqual(tester.mapView.zoomLevel,
                       newZoom,
                       @"initial setup should have differing zoom");
 
     tester.mapView.zoomLevel = newZoom;
 
-    __KIFAssertEqual(tester.mapView.zoomLevel,
-                     newZoom,
-                     @"setting zoom should take effect");
+    XCTAssertEqualWithAccuracy(tester.mapView.zoomLevel,
+                               newZoom,
+                               0.01,
+                               @"setting zoom should take effect");
 }
 
 - (void)testTopLayoutGuide {
@@ -233,7 +290,7 @@
     logoBugFrame = [logoBug.superview convertRect:logoBug.frame toView:nil];
     toolbarFrame = [tester.window convertRect:toolbar.frame toView:nil];
     XCTAssertFalse(CGRectIntersectsRect(logoBugFrame, toolbarFrame),
-                   @"rotated device should not have logo buy under toolbar");
+                   @"rotated device should not have logo bug under toolbar");
 
     attributionButtonFrame = [attributionButton.superview convertRect:attributionButton.frame toView:nil];
     XCTAssertFalse(CGRectIntersectsRect(attributionButtonFrame, toolbarFrame),
@@ -241,11 +298,11 @@
 }
 
 - (void)testDelegateRegionWillChange {
-    __block NSUInteger unanimatedCount = 0;
-    __block NSUInteger animatedCount = 0;
+    __block NSUInteger unanimatedCount;
+    __block NSUInteger animatedCount;
     [[NSNotificationCenter defaultCenter] addObserverForName:@"regionWillChangeAnimated"
                                                       object:tester.mapView
-                                                       queue:[NSOperationQueue mainQueue]
+                                                       queue:nil
                                                   usingBlock:^(NSNotification *note) {
                                                       if ([note.userInfo[@"animated"] boolValue]) {
                                                           animatedCount++;
@@ -254,35 +311,40 @@
                                                       }
                                                   }];
 
+    [tester waitForTimeInterval:1];
+
+    unanimatedCount = 0;
+    animatedCount = 0;
+
     NSNotification *notification = [system waitForNotificationName:@"regionWillChangeAnimated"
                                                             object:tester.mapView
                                                whileExecutingBlock:^{
                                                    tester.mapView.centerCoordinate = CLLocationCoordinate2DMake(0, 0);
                                                }];
+
     [tester waitForTimeInterval:1];
-    XCTAssertNotNil(notification,
-                    @"regionWillChange delegate should produce a notification");
-    __KIFAssertEqual([notification.userInfo[@"animated"] boolValue],
-                     NO,
-                     @"regionWillChange delegate should not indicate animated change");
-    __KIFAssertEqual(unanimatedCount,
-                     1,
-                     @"regionWillChange delegate should indicate one unanimated change");
+
+    XCTAssertEqual([notification.userInfo[@"animated"] boolValue],
+                   NO,
+                   @"regionWillChange delegate should not indicate animated change");
+    XCTAssertEqual(unanimatedCount,
+                   1,
+                   @"regionWillChange delegate should indicate one unanimated change");
 
     notification = [system waitForNotificationName:@"regionWillChangeAnimated"
                                             object:tester.mapView
                                whileExecutingBlock:^{
                                    [tester.mapView setCenterCoordinate:CLLocationCoordinate2DMake(45, 100) animated:YES];
                                }];
+
     [tester waitForTimeInterval:1];
-    XCTAssertNotNil(notification,
-                    @"regionWillChange delegate should produce a notification");
-    __KIFAssertEqual([notification.userInfo[@"animated"] boolValue],
-                     YES,
-                     @"regionWillChange delegate should indicate an animated change");
-    __KIFAssertEqual(animatedCount,
-                     1,
-                     @"regionWillChange delegate should indicate one animated change");
+
+    XCTAssertEqual([notification.userInfo[@"animated"] boolValue],
+                   YES,
+                   @"regionWillChange delegate should indicate an animated change");
+    XCTAssertEqual(animatedCount,
+                   1,
+                   @"regionWillChange delegate should indicate one animated change");
 
     [[NSNotificationCenter defaultCenter] removeObserver:self
                                                     name:@"regionWillChangeAnimated"
@@ -296,11 +358,11 @@
 }
 
 - (void)testDelegateRegionDidChange {
-    __block NSUInteger unanimatedCount = 0;
-    __block NSUInteger animatedCount = 0;
+    __block NSUInteger unanimatedCount;
+    __block NSUInteger animatedCount;
     [[NSNotificationCenter defaultCenter] addObserverForName:@"regionDidChangeAnimated"
                                                       object:tester.mapView
-                                                       queue:[NSOperationQueue mainQueue]
+                                                       queue:nil
                                                   usingBlock:^(NSNotification *note) {
                                                       if ([note.userInfo[@"animated"] boolValue]) {
                                                           animatedCount++;
@@ -309,35 +371,40 @@
                                                       }
                                                   }];
 
+    [tester waitForTimeInterval:1];
+
+    unanimatedCount = 0;
+    animatedCount = 0;
+
     NSNotification *notification = [system waitForNotificationName:@"regionDidChangeAnimated"
                                                             object:tester.mapView
                                                whileExecutingBlock:^{
                                                    tester.mapView.centerCoordinate = CLLocationCoordinate2DMake(0, 0);
                                                }];
+
     [tester waitForTimeInterval:1];
-    XCTAssertNotNil(notification,
-                    @"regionDidChange delegate should produce a notification");
-    __KIFAssertEqual([notification.userInfo[@"animated"] boolValue],
-                     NO,
-                     @"regionDidChange delegate should not indicate animated change");
-    __KIFAssertEqual(unanimatedCount,
-                     1,
-                     @"regionDidChange delegate should indicate one unanimated change");
+
+    XCTAssertEqual([notification.userInfo[@"animated"] boolValue],
+                   NO,
+                   @"regionDidChange delegate should not indicate animated change");
+    XCTAssertEqual(unanimatedCount,
+                   1,
+                   @"regionDidChange delegate should indicate one unanimated change");
 
     notification = [system waitForNotificationName:@"regionDidChangeAnimated"
                                             object:tester.mapView
                                whileExecutingBlock:^{
                                    [tester.mapView setCenterCoordinate:CLLocationCoordinate2DMake(45, 100) animated:YES];
                                }];
+
     [tester waitForTimeInterval:1];
-    XCTAssertNotNil(notification,
-                    @"regionDidChange delegate should produce a notification");
-    __KIFAssertEqual([notification.userInfo[@"animated"] boolValue],
-                     YES,
-                     @"regionDidChange delegate should indicate animated change");
-    __KIFAssertEqual(animatedCount,
-                     1,
-                     @"regionDidChange delegate should indicate one animated change");
+
+    XCTAssertEqual([notification.userInfo[@"animated"] boolValue],
+                   YES,
+                   @"regionDidChange delegate should indicate animated change");
+    XCTAssertEqual(animatedCount,
+                   1,
+                   @"regionDidChange delegate should indicate one animated change");
 
     [[NSNotificationCenter defaultCenter] removeObserver:self
                                                     name:@"regionDidChangeAnimated"