test cases for tap, pinch, and pan gesturest completedfeature/touch_manager_gesture_cancellation_673

Signed-off-by: NicoleYarroch <nicole@livio.io>

2 files changed, 191 insertions, 137 deletions

diff --git a/SmartDeviceLink/SDLTouchManager.m b/SmartDeviceLink/SDLTouchManager.m
index 68f3e2920..c0e046c7d 100644
--- a/SmartDeviceLink/SDLTouchManager.m
+++ b/SmartDeviceLink/SDLTouchManager.m
@@ -234,14 +234,7 @@ static NSUInteger const MaximumNumberOfTouches = 2;
 
     switch (self.performingTouchType) {
             case SDLPerformingTouchTypeMultiTouch:
-            switch (touch.identifier) {
-                    case SDLTouchIdentifierFirstFinger:
-                    self.currentPinchGesture.firstTouch = touch;
-                    break;
-                    case SDLTouchIdentifierSecondFinger:
-                    self.currentPinchGesture.secondTouch = touch;
-                    break;
-            }
+            [self sdl_setMultiTouchFingerTouchForTouch:touch];
             if (self.currentPinchGesture.isValid) {
                 if ([self.touchEventDelegate respondsToSelector:@selector(touchManager:pinchDidEndAtCenterPoint:)]) {
                     [self.touchEventDelegate touchManager:self
@@ -259,10 +252,12 @@ static NSUInteger const MaximumNumberOfTouches = 2;
             break;
 
             case SDLPerformingTouchTypeSingleTouch:
-            if (self.singleTapTimer == nil) { // Initial Tap
+            if (self.singleTapTimer == nil) {
+                // Initial Tap
                 self.singleTapTouch = touch;
                 [self sdl_initializeSingleTapTimerAtPoint:self.singleTapTouch.location];
-            } else { // Double Tap
+            } else {
+                // Double Tap
                 [self sdl_cancelSingleTapTimer];
 
                 NSUInteger timeStampDelta = touch.timeStamp - self.singleTapTouch.timeStamp;
@@ -290,7 +285,7 @@ static NSUInteger const MaximumNumberOfTouches = 2;
 }
 
 /**
- *  Handles a CANCEL touch event sent by CORE. The CANCEL touch event is sent when a gesture is interrupted during a video stream. This can happen when a native dialog box appears on the screen, such as when an incoming phone call is received. Tap gestures are simply canceled and subscribers are not notified. Pinch and pan gesture subscribers are notified if a gesture is canceled.
+ *  Handles a CANCEL touch event sent by CORE. The CANCEL touch event is sent when a gesture is interrupted during a video stream. This can happen when a system dialog box appears on the screen, such as when the user is alerted about an incoming phone call. Tap gestures are simply canceled and subscribers are not notified. Pinch and pan gesture subscribers are notified if a gesture is canceled.
  *
  *  @param touch    Gesture information
  */
@@ -306,6 +301,7 @@ static NSUInteger const MaximumNumberOfTouches = 2;
 
     switch (self.performingTouchType) {
             case SDLPerformingTouchTypeMultiTouch:
+            [self sdl_setMultiTouchFingerTouchForTouch:touch];
             if (self.currentPinchGesture.isValid) {
                 if ([self.touchEventDelegate respondsToSelector:@selector(touchManager:pinchCanceledAtCenterPoint:)]) {
                     [self.touchEventDelegate touchManager:self
@@ -331,6 +327,17 @@ static NSUInteger const MaximumNumberOfTouches = 2;
     _performingTouchType = SDLPerformingTouchTypeNone;
 }
 
+- (void)sdl_setMultiTouchFingerTouchForTouch:(SDLTouch *)touch {
+    switch (touch.identifier) {
+        case SDLTouchIdentifierFirstFinger:
+            self.currentPinchGesture.firstTouch = touch;
+            break;
+        case SDLTouchIdentifierSecondFinger:
+            self.currentPinchGesture.secondTouch = touch;
+            break;
+    }
+}
+
 /**
  *  Creates a timer used to distinguish between single and double tap gestures
  *
diff --git a/SmartDeviceLinkTests/UtilitiesSpecs/Touches/SDLTouchManagerSpec.m b/SmartDeviceLinkTests/UtilitiesSpecs/Touches/SDLTouchManagerSpec.m
index 26381953c..801afabbb 100644
--- a/SmartDeviceLinkTests/UtilitiesSpecs/Touches/SDLTouchManagerSpec.m
+++ b/SmartDeviceLinkTests/UtilitiesSpecs/Touches/SDLTouchManagerSpec.m
@@ -34,7 +34,6 @@
 QuickSpecBegin(SDLTouchManagerSpec)
 
 describe(@"SDLTouchManager Tests", ^{
-
     __block SDLTouchManager* touchManager;
 
     context(@"initializing", ^{
@@ -64,16 +63,16 @@ describe(@"SDLTouchManager Tests", ^{
         __block BOOL didCallEndPinch;
         __block BOOL didCallCancelPinch;
 
-        __block BOOL shouldCallSingleTap;
-        __block BOOL shouldCallDoubleTap;
-        __block BOOL shouldCallBeginPan;
-        __block BOOL shouldCallMovePan;
-        __block BOOL shouldCallEndPan;
-        __block BOOL shouldCallCancelPan;
-        __block BOOL shouldCallBeginPinch;
-        __block BOOL shouldCallMovePinch;
-        __block BOOL shouldCallEndPinch;
-        __block BOOL shouldCallCancelPinch;
+        __block BOOL expectedDidCallSingleTap;
+        __block BOOL expectedDidCallDoubleTap;
+        __block BOOL expectedDidCallBeginPan;
+        __block BOOL expectedDidCallMovePan;
+        __block BOOL expectedDidCallEndPan;
+        __block BOOL expectedDidCallCancelPan;
+        __block BOOL expectedDidCallBeginPinch;
+        __block BOOL expectedDidCallMovePinch;
+        __block BOOL expectedDidCallEndPinch;
+        __block BOOL expectedDidCallCancelPinch;
 
         __block DelegateCallbackBlock singleTapTests;
         __block DelegateCallbackBlock doubleTapTests;
@@ -88,8 +87,8 @@ describe(@"SDLTouchManager Tests", ^{
 
         __block CGFloat additionalWaitTime = 1.0f;
 
-        __block NSUInteger numTimesHandlerCalled = 0;
-        __block NSUInteger expectedNumTimesHandlerCalled = 0;
+        __block NSUInteger numTimesHandlerCalled;
+        __block NSUInteger expectedNumTimesHandlerCalled;
 
         __block void (^performTouchEvent)(SDLTouchManager* touchManager, SDLOnTouchEvent* onTouchEvent) = ^(SDLTouchManager* touchManager, SDLOnTouchEvent* onTouchEvent) {
             SDLRPCNotificationNotification *notification = [[SDLRPCNotificationNotification alloc] initWithName:SDLDidReceiveTouchEventNotification object:nil rpcNotification:onTouchEvent];
@@ -197,22 +196,22 @@ describe(@"SDLTouchManager Tests", ^{
                 failWithMessage(@"Failed to call Pinch Cancel Tests.");
             };
 
-            shouldCallSingleTap = NO;
-            shouldCallDoubleTap = NO;
-            shouldCallBeginPan = NO;
-            shouldCallMovePan = NO;
-            shouldCallEndPan = NO;
-            shouldCallCancelPan = NO;
-            shouldCallBeginPinch = NO;
-            shouldCallMovePinch = NO;
-            shouldCallEndPinch = NO;
-            shouldCallCancelPinch = NO;
+            expectedDidCallSingleTap = NO;
+            expectedDidCallDoubleTap = NO;
+            expectedDidCallBeginPan = NO;
+            expectedDidCallMovePan = NO;
+            expectedDidCallEndPan = NO;
+            expectedDidCallCancelPan = NO;
+            expectedDidCallBeginPinch = NO;
+            expectedDidCallMovePinch = NO;
+            expectedDidCallEndPinch = NO;
+            expectedDidCallCancelPinch = NO;
 
             numTimesHandlerCalled = 0;
             expectedNumTimesHandlerCalled = 0;
         });
 
-        describe(@"Single Finger", ^{
+        describe(@"When receiving a tap gesture", ^{
             __block SDLTouchCoord* firstTouchCoord;
             __block NSUInteger firstTouchTimeStamp;
             __block SDLOnTouchEvent* firstOnTouchEventStart;
@@ -242,7 +241,6 @@ describe(@"SDLTouchManager Tests", ^{
                 it(@"should correctly handle a single tap", ^{
                     singleTapTests = ^(NSInvocation* invocation) {
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
-
                         CGPoint point;
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&point atIndex:3];
@@ -254,7 +252,7 @@ describe(@"SDLTouchManager Tests", ^{
                     performTouchEvent(touchManager, firstOnTouchEventStart);
                     performTouchEvent(touchManager, firstOnTouchEventEnd);
 
-                    shouldCallSingleTap = YES;
+                    expectedDidCallSingleTap = YES;
                     expectedNumTimesHandlerCalled = 2;
                 });
             });
@@ -295,7 +293,6 @@ describe(@"SDLTouchManager Tests", ^{
                     it(@"should issue delegate callbacks", ^{
                         doubleTapTests = ^(NSInvocation* invocation) {
                             __unsafe_unretained SDLTouchManager* touchManagerCallback;
-
                             CGPoint point;
                             [invocation getArgument:&touchManagerCallback atIndex:2];
                             [invocation getArgument:&point atIndex:3];
@@ -309,7 +306,7 @@ describe(@"SDLTouchManager Tests", ^{
                         performTouchEvent(touchManager, secondOnTouchEventStart);
                         performTouchEvent(touchManager, secondOnTouchEventEnd);
                         
-                        shouldCallDoubleTap = YES;
+                        expectedDidCallDoubleTap = YES;
                         expectedNumTimesHandlerCalled = 4;
                     });
                 });
@@ -329,13 +326,13 @@ describe(@"SDLTouchManager Tests", ^{
                         performTouchEvent(touchManager, secondOnTouchEventStart);
                         performTouchEvent(touchManager, secondOnTouchEventEnd);
 
-                        shouldCallDoubleTap = NO;
+                        expectedDidCallDoubleTap = NO;
                         expectedNumTimesHandlerCalled = 4;
                     });
                 });
             });
 
-            describe(@"when a single or double tap is canceled", ^{
+            describe(@"when a tap gesture is canceled", ^{
                 __block SDLOnTouchEvent* onTouchEventCanceled;
                 __block SDLTouchEvent* cancelTouchEvent;
                 __block int notificationCount;
@@ -358,13 +355,17 @@ describe(@"SDLTouchManager Tests", ^{
                     onTouchEventCanceled.event = [NSArray arrayWithObject:cancelTouchEvent];
                 });
 
-                it(@"should not notify delegates when a single tap is canceled", ^{
-                    performTouchEvent(touchManager, firstOnTouchEventStart);
-                    performTouchEvent(touchManager, onTouchEventCanceled);
-                    expectedNumTimesHandlerCalled = 2;
+                context(@"when a single tap is canceled", ^{
+                    it(@"should not issue delegate callbacks for a canceled single tap", ^{
+                        performTouchEvent(touchManager, firstOnTouchEventStart);
+                        performTouchEvent(touchManager, onTouchEventCanceled);
+
+                        expectedDidCallSingleTap = NO;
+                        expectedNumTimesHandlerCalled = 2;
+                    });
                 });
 
-                context(@"should not notify delegates when a double tap is canceled", ^{
+                context(@"when a double tap is canceled", ^{
                     __block SDLOnTouchEvent* secondOnTouchEventStart;
                     __block SDLOnTouchEvent* secondOnTouchEventCancel;
                     __block SDLTouchEvent* secondTouchEvent;
@@ -384,24 +385,24 @@ describe(@"SDLTouchManager Tests", ^{
                         secondOnTouchEventCancel.event = [NSArray arrayWithObject:secondTouchEvent];
                     });
 
-                    it(@"should not notify delegates when the second tap of a double tap is canceled", ^{
+                    it(@"should not issue delegate callbacks when the second tap of a double tap is canceled", ^{
                         performTouchEvent(touchManager, firstOnTouchEventStart);
                         performTouchEvent(touchManager, firstOnTouchEventEnd);
                         performTouchEvent(touchManager, secondOnTouchEventStart);
                         performTouchEvent(touchManager, secondOnTouchEventCancel);
 
-                        shouldCallDoubleTap = NO;
+                        expectedDidCallDoubleTap = NO;
                         expectedNumTimesHandlerCalled = 4;
                     });
 
-                    it(@"should not notify delegates when a double tap is canceled before the start of the second tap", ^{
-                        // If timer threshold is less than 1 second, the single tap timer may send a single tap notification before the timer can be canceled by the CANCEL onTouchEvent
+                    it(@"should not issue delegate callbacks when a double tap is canceled before the start of the second tap", ^{
+                        // If the single tap timer threshold is set to less than 1 second, a single tap notification may be sent before the timer can be canceled by the CANCEL onTouchEvent
                         touchManager.tapTimeThreshold = 1.0;
                         performTouchEvent(touchManager, firstOnTouchEventStart);
                         performTouchEvent(touchManager, firstOnTouchEventEnd);
                         performTouchEvent(touchManager, secondOnTouchEventCancel);
 
-                        shouldCallDoubleTap = NO;
+                        expectedDidCallDoubleTap = NO;
                         expectedNumTimesHandlerCalled = 3;
                     });
                 });
@@ -513,13 +514,11 @@ describe(@"SDLTouchManager Tests", ^{
                 panCancelAfterSecondMoveOnTouchEvent.type = SDLTouchTypeCancel;
             });
 
-            context(@"When a pan gesture is started and ended successfully", ^{
-                it(@"should correctly give all pan callbacks", ^{
+            context(@"When a pan gesture not interrupted", ^{
+                it(@"should correctly issue all pan delegate callbacks", ^{
                     panStartTests = ^(NSInvocation* invocation) {
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
-
                         CGPoint point;
-
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&point atIndex:3];
 
@@ -529,10 +528,8 @@ describe(@"SDLTouchManager Tests", ^{
 
                     panMoveTests = ^(NSInvocation* invocation) {
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
-
                         CGPoint startPoint;
                         CGPoint endPoint;
-
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&startPoint atIndex:3];
                         [invocation getArgument:&endPoint atIndex:4];
@@ -544,9 +541,7 @@ describe(@"SDLTouchManager Tests", ^{
 
                     panEndTests = ^(NSInvocation* invocation) {
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
-
                         CGPoint point;
-
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&point atIndex:3];
 
@@ -559,19 +554,18 @@ describe(@"SDLTouchManager Tests", ^{
                     performTouchEvent(touchManager, panSecondMoveOnTouchEvent);
                     performTouchEvent(touchManager, panEndOnTouchEvent);
 
-                    shouldCallBeginPan = YES;
-                    shouldCallMovePan = YES;
-                    shouldCallEndPan = YES;
-                    shouldCallCancelPan = NO;
+                    expectedDidCallBeginPan = YES;
+                    expectedDidCallMovePan = YES;
+                    expectedDidCallEndPan = YES;
+                    expectedDidCallCancelPan = NO;
                     expectedNumTimesHandlerCalled = 4;
                 });
             });
 
             context(@"when a pan gesture is canceled", ^{
-                it(@"should notify delegates a pan is canceled right after first move detected", ^{
+                it(@"should issue a cancel pan delegate callback when the pan is canceled right after first move detected", ^{
                     panStartTests = ^(NSInvocation* invocation) {
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
-
                         CGPoint point;
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&point atIndex:3];
@@ -582,7 +576,6 @@ describe(@"SDLTouchManager Tests", ^{
 
                     panCanceledTests = ^(NSInvocation* invocation) {
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
-
                         CGPoint point;
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&point atIndex:3];
@@ -595,19 +588,17 @@ describe(@"SDLTouchManager Tests", ^{
                     performTouchEvent(touchManager, panMoveOnTouchEvent);
                     performTouchEvent(touchManager, panCancelAfterMoveOnTouchEvent);
 
-                    shouldCallBeginPan = YES;
-                    shouldCallMovePan = NO;
-                    shouldCallEndPan = NO;
-                    shouldCallCancelPan = YES;
+                    expectedDidCallBeginPan = YES;
+                    expectedDidCallMovePan = NO;
+                    expectedDidCallEndPan = NO;
+                    expectedDidCallCancelPan = YES;
                     expectedNumTimesHandlerCalled = 3;
                 });
 
-                it(@"should notify delegates a pan is canceled right after second move detected", ^{
+                it(@"should issue a cancel pan delegate callback when a pan is canceled right after second move detected", ^{
                     panStartTests = ^(NSInvocation* invocation) {
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
-
                         CGPoint point;
-
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&point atIndex:3];
 
@@ -617,10 +608,8 @@ describe(@"SDLTouchManager Tests", ^{
 
                     panMoveTests = ^(NSInvocation* invocation) {
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
-
                         CGPoint startPoint;
                         CGPoint endPoint;
-
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&startPoint atIndex:3];
                         [invocation getArgument:&endPoint atIndex:4];
@@ -632,11 +621,9 @@ describe(@"SDLTouchManager Tests", ^{
 
                     panCanceledTests = ^(NSInvocation* invocation) {
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
-
                         CGPoint point;
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&point atIndex:3];
-
                         expect(touchManagerCallback).to(equal(touchManager));
                         expect(@(CGPointEqualToPoint(point, panCancelPointAfterSecondMove))).to(beTruthy());
                     };
@@ -646,20 +633,30 @@ describe(@"SDLTouchManager Tests", ^{
                     performTouchEvent(touchManager, panSecondMoveOnTouchEvent);
                     performTouchEvent(touchManager, panCancelAfterMoveOnTouchEvent);
 
-                    shouldCallBeginPan = YES;
-                    shouldCallMovePan = YES;
-                    shouldCallEndPan = NO;
-                    shouldCallCancelPan = YES;
+                    expectedDidCallBeginPan = YES;
+                    expectedDidCallMovePan = YES;
+                    expectedDidCallEndPan = NO;
+                    expectedDidCallCancelPan = YES;
                     expectedNumTimesHandlerCalled = 4;
                 });
 
+                it(@"should not issue a cancel pan delegate callback if the cancel onTouchEvent is received while a pan gesture is not in progress", ^{
+                    performTouchEvent(touchManager, panCancelAfterSecondMoveOnTouchEvent);
+
+                    expectedDidCallBeginPan = NO;
+                    expectedDidCallMovePan = NO;
+                    expectedDidCallEndPan = NO;
+                    expectedDidCallCancelPan = NO;
+                    expectedNumTimesHandlerCalled = 1;
+                });
+
                 afterEach(^{
                     expect(touchManager.currentPinchGesture).toEventually(beNil());
                 });
             });
         });
 
-        context(@"when receiving a pinch", ^{
+        context(@"when receiving a pinch gesture", ^{
             __block CGPoint pinchStartCenter;
             __block CGPoint pinchMoveCenter;
             __block CGFloat pinchMoveScale;
@@ -675,19 +672,14 @@ describe(@"SDLTouchManager Tests", ^{
             __block SDLOnTouchEvent* pinchCancelSecondFingerOnTouchEvent;
 
             beforeEach(^{
-                numTimesHandlerCalled = 0;
-
                 // First finger touch down
                 SDLTouchCoord* firstFingerTouchCoord = [[SDLTouchCoord alloc] init];
                 firstFingerTouchCoord.x = @(controlPoint.x);
                 firstFingerTouchCoord.y = @(controlPoint.y);
-
                 NSUInteger firstFingerTimeStamp = [[NSDate date] timeIntervalSince1970] * 1000;
-
                 SDLTouchEvent* firstFingerTouchEvent = [[SDLTouchEvent alloc] init];
                 firstFingerTouchEvent.coord = [NSArray arrayWithObject:firstFingerTouchCoord];
                 firstFingerTouchEvent.timeStamp = [NSArray arrayWithObject:@(firstFingerTimeStamp)];
-
                 pinchStartFirstFingerOnTouchEvent = [[SDLOnTouchEvent alloc] init];
                 pinchStartFirstFingerOnTouchEvent.event = [NSArray arrayWithObject:firstFingerTouchEvent];
                 pinchStartFirstFingerOnTouchEvent.type = SDLTouchTypeBegin;
@@ -696,21 +688,16 @@ describe(@"SDLTouchManager Tests", ^{
                 SDLTouchCoord* secondFingerTouchCoord = [[SDLTouchCoord alloc] init];
                 secondFingerTouchCoord.x = @(firstFingerTouchCoord.x.floatValue + 100);
                 secondFingerTouchCoord.y = @(firstFingerTouchCoord.y.floatValue + 100);
-
                 NSUInteger secondFingerTimeStamp = firstFingerTimeStamp;
-
                 SDLTouchEvent* secondFingerTouchEvent = [[SDLTouchEvent alloc] init];
                 secondFingerTouchEvent.touchEventId = @1;
                 secondFingerTouchEvent.coord = [NSArray arrayWithObject:secondFingerTouchCoord];
                 secondFingerTouchEvent.timeStamp = [NSArray arrayWithObject:@(secondFingerTimeStamp)];
-
                 pinchStartSecondFingerOnTouchEvent = [[SDLOnTouchEvent alloc] init];
                 pinchStartSecondFingerOnTouchEvent.event = [NSArray arrayWithObject:secondFingerTouchEvent];
                 pinchStartSecondFingerOnTouchEvent.type = SDLTouchTypeBegin;
-
                 pinchStartCenter = CGPointMake((firstFingerTouchCoord.x.floatValue + secondFingerTouchCoord.x.floatValue) / 2.0f,
                                                (firstFingerTouchCoord.y.floatValue + secondFingerTouchCoord.y.floatValue) / 2.0f);
-
                 CGFloat pinchStartDistance = hypotf(firstFingerTouchCoord.x.floatValue - secondFingerTouchCoord.x.floatValue,
                                                     firstFingerTouchCoord.y.floatValue - secondFingerTouchCoord.y.floatValue);
 
@@ -718,40 +705,30 @@ describe(@"SDLTouchManager Tests", ^{
                 SDLTouchCoord* secondFingerMoveTouchCoord = [[SDLTouchCoord alloc] init];
                 secondFingerMoveTouchCoord.x = @(secondFingerTouchCoord.x.floatValue - 50);
                 secondFingerMoveTouchCoord.y = @(secondFingerTouchCoord.y.floatValue - 40);
-
                 NSUInteger secondFingerMoveTimeStamp = secondFingerTimeStamp + ((touchManager.movementTimeThreshold + 0.1) * 1000);
-
                 SDLTouchEvent* secondFingerMoveTouchEvent = [[SDLTouchEvent alloc] init];
                 secondFingerMoveTouchEvent.touchEventId = @1;
                 secondFingerMoveTouchEvent.coord = [NSArray arrayWithObject:secondFingerMoveTouchCoord];
                 secondFingerMoveTouchEvent.timeStamp = [NSArray arrayWithObject:@(secondFingerMoveTimeStamp)];
-
                 pinchMoveSecondFingerOnTouchEvent = [[SDLOnTouchEvent alloc] init];
                 pinchMoveSecondFingerOnTouchEvent.event = [NSArray arrayWithObject:secondFingerMoveTouchEvent];
                 pinchMoveSecondFingerOnTouchEvent.type = SDLTouchTypeMove;
-
                 pinchMoveCenter = CGPointMake((firstFingerTouchCoord.x.floatValue + secondFingerMoveTouchCoord.x.floatValue) / 2.0f,
                                               (firstFingerTouchCoord.y.floatValue + secondFingerMoveTouchCoord.y.floatValue) / 2.0f);
-
                 CGFloat pinchMoveDistance = hypotf(firstFingerTouchCoord.x.floatValue - secondFingerMoveTouchCoord.x.floatValue,
                                                    firstFingerTouchCoord.y.floatValue - secondFingerMoveTouchCoord.y.floatValue);
-
                 pinchMoveScale = pinchMoveDistance / pinchStartDistance;
 
                 // Second finger end
                 SDLTouchCoord* secondFingerEndTouchCoord = secondFingerMoveTouchCoord;
-
                 NSUInteger secondFingerEndTimeStamp = secondFingerMoveTimeStamp + ((touchManager.movementTimeThreshold + 0.1) * 1000);
-
                 SDLTouchEvent* secondFingerEndTouchEvent = [[SDLTouchEvent alloc] init];
                 secondFingerEndTouchEvent.touchEventId = @1;
                 secondFingerEndTouchEvent.coord = [NSArray arrayWithObject:secondFingerEndTouchCoord];
                 secondFingerEndTouchEvent.timeStamp = [NSArray arrayWithObject:@(secondFingerEndTimeStamp)];
-
                 pinchEndSecondFingerOnTouchEvent = [[SDLOnTouchEvent alloc] init];
                 pinchEndSecondFingerOnTouchEvent.event = [NSArray arrayWithObject:secondFingerEndTouchEvent];
                 pinchEndSecondFingerOnTouchEvent.type = SDLTouchTypeEnd;
-
                 pinchEndCenter = CGPointMake((firstFingerTouchCoord.x.floatValue + secondFingerEndTouchCoord.x.floatValue) / 2.0f, (firstFingerTouchCoord.y.floatValue + secondFingerEndTouchCoord.y.floatValue) / 2.0f);
 
                 // First finger cancel
@@ -764,7 +741,7 @@ describe(@"SDLTouchManager Tests", ^{
                 pinchCancelFirstFingerOnTouchEvent = [[SDLOnTouchEvent alloc] init];
                 pinchCancelFirstFingerOnTouchEvent.event = [NSArray arrayWithObject:firstFingerCanceledTouchEvent];
                 pinchCancelFirstFingerOnTouchEvent.type = SDLTouchTypeCancel;
-                pinchFirstFingerCancelCenter = CGPointMake((firstFingerTouchCoord.x.floatValue + secondFingerEndTouchCoord.x.floatValue) / 2.0f, (firstFingerTouchCoord.y.floatValue + secondFingerEndTouchCoord.y.floatValue) / 2.0f);
+                pinchFirstFingerCancelCenter = CGPointMake((firstFingerCanceledTouchCoord.x.floatValue + secondFingerTouchCoord.x.floatValue) / 2.0f, (firstFingerCanceledTouchCoord.y.floatValue + secondFingerTouchCoord.y.floatValue) / 2.0f);
 
                 // Second finger cancel
                 SDLTouchCoord* secondFingerCanceledTouchCoord = secondFingerMoveTouchCoord;
@@ -774,18 +751,17 @@ describe(@"SDLTouchManager Tests", ^{
                 secondFingerCanceledTouchEvent.coord = [NSArray arrayWithObject:secondFingerCanceledTouchCoord];
                 secondFingerCanceledTouchEvent.timeStamp = [NSArray arrayWithObject:@(secondFingerCanceledTimeStamp)];
                 pinchCancelSecondFingerOnTouchEvent = [[SDLOnTouchEvent alloc] init];
-                pinchCancelSecondFingerOnTouchEvent.event = [NSArray arrayWithObject:firstFingerCanceledTouchEvent];
+                pinchCancelSecondFingerOnTouchEvent.event = [NSArray arrayWithObject:secondFingerCanceledTouchEvent];
                 pinchCancelSecondFingerOnTouchEvent.type = SDLTouchTypeCancel;
-                pinchSecondFingerCancelCenter = CGPointMake((firstFingerTouchCoord.x.floatValue + secondFingerEndTouchCoord.x.floatValue) / 2.0f, (firstFingerTouchCoord.y.floatValue + secondFingerEndTouchCoord.y.floatValue) / 2.0f);
+                pinchSecondFingerCancelCenter = CGPointMake((firstFingerTouchCoord.x.floatValue + secondFingerCanceledTouchCoord.x.floatValue) / 2.0f, (firstFingerTouchCoord.y.floatValue + secondFingerCanceledTouchCoord.y.floatValue) / 2.0f);
             });
 
-            context(@"When a pinch gesture is successful", ^{
-                it(@"should correctly send all pinch callbacks", ^{
+            context(@"When a pinch gesture is not interrupted", ^{
+                it(@"should correctly send all pinch delegate callbacks", ^{
                     pinchStartTests = ^(NSInvocation* invocation) {
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
 
                         CGPoint point;
-
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&point atIndex:3];
 
@@ -798,7 +774,6 @@ describe(@"SDLTouchManager Tests", ^{
 
                         CGPoint point;
                         CGFloat scale;
-
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&point atIndex:3];
                         [invocation getArgument:&scale atIndex:4];
@@ -812,7 +787,6 @@ describe(@"SDLTouchManager Tests", ^{
                         __unsafe_unretained SDLTouchManager* touchManagerCallback;
                         
                         CGPoint point;
-                        
                         [invocation getArgument:&touchManagerCallback atIndex:2];
                         [invocation getArgument:&point atIndex:3];
                         
@@ -825,31 +799,103 @@ describe(@"SDLTouchManager Tests", ^{
                     performTouchEvent(touchManager, pinchMoveSecondFingerOnTouchEvent);
                     performTouchEvent(touchManager, pinchEndSecondFingerOnTouchEvent);
 
-                    shouldCallBeginPinch = YES;
-                    shouldCallMovePinch = YES;
-                    shouldCallEndPinch = YES;
-                    shouldCallCancelPinch = NO;
+                    expectedDidCallBeginPinch = YES;
+                    expectedDidCallMovePinch = YES;
+                    expectedDidCallEndPinch = YES;
+                    expectedDidCallCancelPinch = NO;
                     expectedNumTimesHandlerCalled = 4;
                 });
             });
             
             context(@"when a pinch gesture is canceled", ^{
-                it(@"should notify delegates a pinch is canceled right after a pinch move is detected", ^{
-//                    shouldCallBeginPinch = YES;
-//                    shouldCallMovePinch = YES;
-//                    shouldCallEndPinch = YES;
-//                    shouldCallCancelPinch = NO;
-//                    expectedNumTimesHandlerCalled = 4;
+                it(@"should notify delegates if pinch is canceled right after it started", ^{
+                    pinchStartTests = ^(NSInvocation* invocation) {
+                        __unsafe_unretained SDLTouchManager* touchManagerCallback;
+                        CGPoint point;
+                        [invocation getArgument:&touchManagerCallback atIndex:2];
+                        [invocation getArgument:&point atIndex:3];
+
+                        expect(touchManagerCallback).to(equal(touchManager));
+                        expect(@(CGPointEqualToPoint(point, pinchStartCenter))).to(beTruthy());
+                    };
+
+                    pinchCanceledTests = ^(NSInvocation* invocation) {
+                        __unsafe_unretained SDLTouchManager* touchManagerCallback;
+                        CGPoint point;
+                        [invocation getArgument:&touchManagerCallback atIndex:2];
+                        [invocation getArgument:&point atIndex:3];
+
+                        expect(touchManagerCallback).to(equal(touchManager));
+                        expect(@(CGPointEqualToPoint(point, pinchFirstFingerCancelCenter))).to(beTruthy());
+                    };
+
+                    performTouchEvent(touchManager, pinchStartFirstFingerOnTouchEvent);
+                    performTouchEvent(touchManager, pinchStartSecondFingerOnTouchEvent);
+                    performTouchEvent(touchManager, pinchCancelFirstFingerOnTouchEvent);
+
+                    expectedDidCallBeginPinch = YES;
+                    expectedDidCallMovePinch = NO;
+                    expectedDidCallEndPinch = NO;
+                    expectedDidCallCancelPinch = YES;
+                    expectedNumTimesHandlerCalled = 3;
+                });
+
+                it(@"should notify delegates if pinch is canceled while it is in progress", ^{
+                    pinchStartTests = ^(NSInvocation* invocation) {
+                        __unsafe_unretained SDLTouchManager* touchManagerCallback;
+                        CGPoint point;
+                        [invocation getArgument:&touchManagerCallback atIndex:2];
+                        [invocation getArgument:&point atIndex:3];
+
+                        expect(touchManagerCallback).to(equal(touchManager));
+                        expect(@(CGPointEqualToPoint(point, pinchStartCenter))).to(beTruthy());
+                    };
+
+                    pinchMoveTests = ^(NSInvocation* invocation) {
+                        __unsafe_unretained SDLTouchManager* touchManagerCallback;
+                        CGPoint point;
+                        CGFloat scale;
+                        [invocation getArgument:&touchManagerCallback atIndex:2];
+                        [invocation getArgument:&point atIndex:3];
+                        [invocation getArgument:&scale atIndex:4];
+
+                        expect(touchManagerCallback).to(equal(touchManager));
+                        expect(@(CGPointEqualToPoint(point, pinchMoveCenter))).to(beTruthy());
+                        expect(@(scale)).to(beCloseTo(@(pinchMoveScale)).within(0.0001));
+                    };
+
+                    pinchCanceledTests = ^(NSInvocation* invocation) {
+                        __unsafe_unretained SDLTouchManager* touchManagerCallback;
+                        CGPoint point;
+                        [invocation getArgument:&touchManagerCallback atIndex:2];
+                        [invocation getArgument:&point atIndex:3];
+
+                        expect(touchManagerCallback).to(equal(touchManager));
+                        expect(@(CGPointEqualToPoint(point, pinchSecondFingerCancelCenter))).to(beTruthy());
+                    };
+
+                    performTouchEvent(touchManager, pinchStartFirstFingerOnTouchEvent);
+                    performTouchEvent(touchManager, pinchStartSecondFingerOnTouchEvent);
+                    performTouchEvent(touchManager, pinchMoveSecondFingerOnTouchEvent);
+                    performTouchEvent(touchManager, pinchCancelSecondFingerOnTouchEvent);
+
+                    expectedDidCallBeginPinch = YES;
+                    expectedDidCallMovePinch = YES;
+                    expectedDidCallEndPinch = NO;
+                    expectedDidCallCancelPinch = YES;
+                    expectedNumTimesHandlerCalled = 4;
                 });
 
-                it(@"should notify delegates a pinch is canceled right after a pinch move is detected", ^{
-//                    shouldCallBeginPinch = YES;
-//                    shouldCallMovePinch = YES;
-//                    shouldCallEndPinch = YES;
-//                    shouldCallCancelPinch = NO;
-//                    expectedNumTimesHandlerCalled = 4;
+                it(@"should not issue a cancel pinch delegate callback if the cancel onTouchEvent is received while a pinch gesture is not in progress", ^{
+                    performTouchEvent(touchManager, pinchCancelSecondFingerOnTouchEvent);
+
+                    expectedDidCallBeginPinch = NO;
+                    expectedDidCallMovePinch = NO;
+                    expectedDidCallEndPinch = NO;
+                    expectedDidCallCancelPinch = NO;
+                    expectedNumTimesHandlerCalled = 1;
                 });
-                
+
                 afterEach(^{
                     expect(touchManager.currentPinchGesture).toEventually(beNil());
                 });
@@ -857,16 +903,17 @@ describe(@"SDLTouchManager Tests", ^{
         });
 
         afterEach(^{
-            expect(@(didCallSingleTap)).withTimeout(touchManager.tapTimeThreshold + additionalWaitTime).toEventually(shouldCallSingleTap ? beTruthy() : beFalsy());
-            expect(@(didCallDoubleTap)).withTimeout(touchManager.tapTimeThreshold + additionalWaitTime).toEventually(shouldCallDoubleTap ? beTruthy() : beFalsy());
-            expect(@(didCallBeginPan)).withTimeout(touchManager.tapTimeThreshold + additionalWaitTime).toEventually(shouldCallBeginPan ? beTruthy() : beFalsy());
-            expect(@(didCallMovePan)).withTimeout(touchManager.tapTimeThreshold + additionalWaitTime).toEventually(shouldCallMovePan ? beTruthy() : beFalsy());
-            expect(@(didCallEndPan)).withTimeout(touchManager.tapTimeThreshold + additionalWaitTime).toEventually(shouldCallEndPan ? beTruthy() : beFalsy());
-            expect(@(didCallCancelPan)).withTimeout(touchManager.tapTimeThreshold + additionalWaitTime).toEventually(shouldCallCancelPan ? beTruthy() : beFalsy());
-            expect(@(didCallBeginPinch)).withTimeout(touchManager.tapTimeThreshold + additionalWaitTime).toEventually(shouldCallBeginPinch ? beTruthy() : beFalsy());
-            expect(@(didCallMovePinch)).withTimeout(touchManager.tapTimeThreshold + additionalWaitTime).toEventually(shouldCallMovePinch ? beTruthy() : beFalsy());
-            expect(@(didCallEndPinch)).withTimeout(touchManager.tapTimeThreshold + additionalWaitTime).toEventually(shouldCallEndPinch ? beTruthy() : beFalsy());
-            expect(@(didCallCancelPinch)).withTimeout(touchManager.tapTimeThreshold + additionalWaitTime).toEventually(shouldCallCancelPinch ? beTruthy() : beFalsy());
+            CGFloat timeoutTime = touchManager.tapTimeThreshold + additionalWaitTime;
+            expect(@(didCallSingleTap)).withTimeout(timeoutTime).toEventually(expectedDidCallSingleTap ? beTruthy() : beFalsy());
+            expect(@(didCallDoubleTap)).withTimeout(timeoutTime).toEventually(expectedDidCallDoubleTap ? beTruthy() : beFalsy());
+            expect(@(didCallBeginPan)).withTimeout(timeoutTime).toEventually(expectedDidCallBeginPan ? beTruthy() : beFalsy());
+            expect(@(didCallMovePan)).withTimeout(timeoutTime).toEventually(expectedDidCallMovePan ? beTruthy() : beFalsy());
+            expect(@(didCallEndPan)).withTimeout(timeoutTime).toEventually(expectedDidCallEndPan ? beTruthy() : beFalsy());
+            expect(@(didCallCancelPan)).withTimeout(timeoutTime).toEventually(expectedDidCallCancelPan ? beTruthy() : beFalsy());
+            expect(@(didCallBeginPinch)).withTimeout(timeoutTime).toEventually(expectedDidCallBeginPinch ? beTruthy() : beFalsy());
+            expect(@(didCallMovePinch)).withTimeout(timeoutTime).toEventually(expectedDidCallMovePinch ? beTruthy() : beFalsy());
+            expect(@(didCallEndPinch)).withTimeout(timeoutTime).toEventually(expectedDidCallEndPinch ? beTruthy() : beFalsy());
+            expect(@(didCallCancelPinch)).withTimeout(timeoutTime).toEventually(expectedDidCallCancelPinch ? beTruthy() : beFalsy());
 
             expect(numTimesHandlerCalled).to(equal(@(expectedNumTimesHandlerCalled)));
         });