UITapGestureRecognizer déclencher par programmation d'un robinet de mon point de vue

Je pense que vous avez plusieurs options ici:

1. Peut être le plus simple serait d'envoyer un push event action à votre point de vue mais je ne pense pas que ce que vous voulez vraiment puisque vous voulez être en mesure de choisir l'endroit où le robinet d'action se produit.

   [yourView sendActionsForControlEvents: UIControlEventTouchUpInside];

2. Vous pouvez utiliser UI automation tool qui est fourni avec XCode instruments. Cette blog explique bien comment faire pour automatiser vos tests de l'INTERFACE utilisateur avec le script.

3. Il y a cette solution trop qui expliquent comment synthétiser les événements tactiles sur l'iPhone, mais assurez-vous que vous utilisez uniquement celles pour les tests unitaires. Ceci ressemble plus à un hack pour moi et je vais envisager cette solution en dernier recours si les deux points précédents ne pas répondre à votre besoin.

OriginalL'auteur tiguero

Si utilisé dans les tests, vous pouvez utiliser une bibliothèque de test appelé SpecTools qui contribue à tout cela et plus, ou utiliser directement le code:

//Return type alias
public typealias TargetActionInfo = [(target: AnyObject, action: Selector)]

//UIGestureRecognizer extension
extension  UIGestureRecognizer {

    //MARK: Retrieving targets from gesture recognizers

    ///Returns all actions and selectors for a gesture recognizer
    ///This method uses private API's and will most likely cause your app to be rejected if used outside of your test target
    ///- Returns: [(target: AnyObject, action: Selector)] Array of action/selector tuples
    public func getTargetInfo() -> TargetActionInfo {
        var targetsInfo: TargetActionInfo = []

        if let targets = self.value(forKeyPath: "_targets") as? [NSObject] {
            for target in targets {
                //Getting selector by parsing the description string of a UIGestureRecognizerTarget
                let selectorString = String.init(describing: target).components(separatedBy: ", ").first!.replacingOccurrences(of: "(action=", with: "")
                let selector = NSSelectorFromString(selectorString)

                //Getting target from iVars
                let targetActionPairClass: AnyClass = NSClassFromString("UIGestureRecognizerTarget")!
                let targetIvar: Ivar = class_getInstanceVariable(targetActionPairClass, "_target")
                let targetObject: AnyObject = object_getIvar(target, targetIvar) as! AnyObject

                targetsInfo.append((target: targetObject, action: selector))
            }
        }

        return targetsInfo
    }

    ///Executes all targets on a gesture recognizer
    public func execute() {
        let targetsInfo = self.getTargetInfo()
        for info in targetsInfo {
            info.target.performSelector(onMainThread: info.action, with: nil, waitUntilDone: true)
        }
    }

}

À la fois, à la bibliothèque ainsi que l'extrait de l'utilisation privée de l'API et sera probablement entraîner un rejet si elle est utilisée à l'extérieur de votre suite de tests ...

OriginalL'auteur Ondrej

Ok, j'ai tourné la ci-dessus dans une catégorie qui fonctionne.

Bits intéressants:

• Catégories ne pouvez pas ajouter des variables membres. Tout ce que vous ajoutez devient statique de la classe et ainsi est tabassé par Apple de nombreux UITapGestureRecognizers.
  • Ainsi, l'utilisation de associated_object à faire de la magie.
  • NSValue pour le stockage des non-objets
• Apple init méthode contient d'importantes configuration de la logique; on pouvait deviner ce qui est prévu (nombre de prises, le nombre de touches, quoi d'autre?
  • Mais c'est vouée à l'échec. Donc, nous swizzle dans notre méthode init qui préserve les objets fantaisie.

Le fichier d'en-tête est triviale; voici la mise en œuvre.

#import "UITapGestureRecognizer+Spec.h"
#import "objc/runtime.h"
/*
* With great contributions from Matt Gallagher (http://www.cocoawithlove.com/2008/10/synthesizing-touch-event-on-iphone.html)
* And Glauco Aquino (http://stackoverflow.com/users/2276639/glauco-aquino)
* And Codeshaker (http://codeshaker.blogspot.com/2012/01/calling-original-overridden-method-from.html)
*/
@interface UITapGestureRecognizer (SpecPrivate)
@property (strong, nonatomic, readwrite) UIView *mockTappedView_;
@property (assign, nonatomic, readwrite) CGPoint mockTappedPoint_;
@property (strong, nonatomic, readwrite) id mockTarget_;
@property (assign, nonatomic, readwrite) SEL mockAction_;
@end
NSString const *MockTappedViewKey = @"MockTappedViewKey";
NSString const *MockTappedPointKey = @"MockTappedPointKey";
NSString const *MockTargetKey = @"MockTargetKey";
NSString const *MockActionKey = @"MockActionKey";
@implementation UITapGestureRecognizer (Spec)
//It is necessary to call the original init method; super does not set appropriate variables.
//(eg, number of taps, number of touches, gods know what else)
//Swizzle our own method into its place. Note that Apple misspells 'swizzle' as 'exchangeImplementation'.
+(void)load {
method_exchangeImplementations(class_getInstanceMethod(self, @selector(initWithTarget:action:)),
class_getInstanceMethod(self, @selector(initWithMockTarget:mockAction:)));
}
-(id)initWithMockTarget:(id)target mockAction:(SEL)action {
self = [self initWithMockTarget:target mockAction:action];
self.mockTarget_ = target;
self.mockAction_ = action;
self.mockTappedView_ = nil;
return self;
}
-(UIView *)view {
return self.mockTappedView_;
}
-(CGPoint)locationInView:(UIView *)view {
return [view convertPoint:self.mockTappedPoint_ fromView:self.mockTappedView_];
}
//-(UIGestureRecognizerState)state {
//   return UIGestureRecognizerStateEnded;
//}
-(void)performTapWithView:(UIView *)view andPoint:(CGPoint)point {
self.mockTappedView_ = view;
self.mockTappedPoint_ = point;
//warning because a leak is possible because the compiler can't tell whether this method
//adheres to standard naming conventions and make the right behavioral decision. Suppress it.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
[self.mockTarget_ performSelector:self.mockAction_];
#pragma clang diagnostic pop
}
# pragma mark - Who says we can't add members in a category?
- (void)setMockTappedView_:(UIView *)mockTappedView {
objc_setAssociatedObject(self, &MockTappedViewKey, mockTappedView, OBJC_ASSOCIATION_ASSIGN);
}
-(UIView *)mockTappedView_ {
return objc_getAssociatedObject(self, &MockTappedViewKey);
}
- (void)setMockTappedPoint_:(CGPoint)mockTappedPoint {
objc_setAssociatedObject(self, &MockTappedPointKey, [NSValue value:&mockTappedPoint withObjCType:@encode(CGPoint)], OBJC_ASSOCIATION_COPY);
}
- (CGPoint)mockTappedPoint_ {
NSValue *value = objc_getAssociatedObject(self, &MockTappedPointKey);
CGPoint aPoint;
[value getValue:&aPoint];
return aPoint;
}
- (void)setMockTarget_:(id)mockTarget {
objc_setAssociatedObject(self, &MockTargetKey, mockTarget, OBJC_ASSOCIATION_ASSIGN);
}
- (id)mockTarget_ {
return objc_getAssociatedObject(self, &MockTargetKey);
}
- (void)setMockAction_:(SEL)mockAction {
objc_setAssociatedObject(self, &MockActionKey, NSStringFromSelector(mockAction), OBJC_ASSOCIATION_COPY);
}
- (SEL)mockAction_ {
NSString *selectorString = objc_getAssociatedObject(self, &MockActionKey);
return NSSelectorFromString(selectorString);
}
@end

OriginalL'auteur tooluser

Réponse par @Ondrej mis à jour à Swift 4:

//Return type alias
typealias TargetActionInfo = [(target: AnyObject, action: Selector)]
//UIGestureRecognizer extension
extension  UIGestureRecognizer {
//MARK: Retrieving targets from gesture recognizers
///Returns all actions and selectors for a gesture recognizer
///This method uses private API's and will most likely cause your app to be rejected if used outside of your test target
///- Returns: [(target: AnyObject, action: Selector)] Array of action/selector tuples
func getTargetInfo() -> TargetActionInfo {
guard let targets = value(forKeyPath: "_targets") as? [NSObject] else {
return []
}
var targetsInfo: TargetActionInfo = []
for target in targets {
//Getting selector by parsing the description string of a UIGestureRecognizerTarget
let description = String(describing: target).trimmingCharacters(in: CharacterSet(charactersIn: "()"))
var selectorString = description.components(separatedBy: ", ").first ?? ""
selectorString = selectorString.components(separatedBy: "=").last ?? ""
let selector = NSSelectorFromString(selectorString)
//Getting target from iVars
if let targetActionPairClass = NSClassFromString("UIGestureRecognizerTarget"),
let targetIvar = class_getInstanceVariable(targetActionPairClass, "_target"),
let targetObject = object_getIvar(target, targetIvar) {
targetsInfo.append((target: targetObject as AnyObject, action: selector))
}
}
return targetsInfo
}
///Executes all targets on a gesture recognizer
func sendActions() {
let targetsInfo = getTargetInfo()
for info in targetsInfo {
info.target.performSelector(onMainThread: info.action, with: self, waitUntilDone: true)
}
}
}

Utilisation:

struct Automator {
static func tap(view: UIView) {
let grs = view.gestureRecognizers?.compactMap { $0 as? UITapGestureRecognizer } ?? []
grs.forEach { $0.sendActions() }
}
}
let myView = ... //View under UI Logic Test
Automator.tap(view: myView)

OriginalL'auteur Vlad