appium-webdriveragent 4.6.0 → 4.8.0

package/WebDriverAgentLib/Categories/XCUIElement+FBCaching.m

@@ -11,6 +11,7 @@
 
 #import <objc/runtime.h>
 
+#import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "XCUIElement+FBWebDriverAttributes.h"
 #import "XCUIElement+FBUtilities.h"
 #import "XCUIElement+FBUID.h"
@@ -46,8 +47,8 @@ static char XCUIELEMENT_CACHE_ID_KEY;
   if ([self isKindOfClass:XCUIApplication.class]) {
     uid = self.fb_uid;
   } else {
-    XCElementSnapshot *snapshot = self.fb_cachedSnapshot ?: self.fb_takeSnapshot;
-    uid = snapshot.wdUID;
+    id<FBXCElementSnapshot> snapshot = self.fb_cachedSnapshot ?: self.fb_takeSnapshot;
+    uid = [FBXCElementSnapshotWrapper ensureWrapped:snapshot].wdUID;
   }
 
   objc_setAssociatedObject(self, &XCUIELEMENT_CACHE_ID_KEY, uid, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

package/WebDriverAgentLib/Categories/XCUIElement+FBFind.m

@@ -12,10 +12,8 @@
 
 #import "FBMacros.h"
 #import "FBElementTypeTransformer.h"
-#import "FBPredicate.h"
 #import "NSPredicate+FBFormat.h"
-#import "XCElementSnapshot.h"
-#import "XCElementSnapshot+FBHelpers.h"
+#import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "FBXCodeCompatibility.h"
 #import "XCUIElement+FBCaching.h"
 #import "XCUIElement+FBUtilities.h"
@@ -37,7 +35,7 @@
   return matchedElement ? @[matchedElement] : @[];
 }
 
-- (XCElementSnapshot *)fb_cachedSnapshotWithQuery:(XCUIElementQuery *)query
+- (id<FBXCElementSnapshot>)fb_cachedSnapshotWithQuery:(XCUIElementQuery *)query
 {
   return [self isKindOfClass:XCUIApplication.class] ? query.rootElementSnapshot : self.fb_cachedSnapshot;
 }
@@ -51,7 +49,7 @@
   XCUIElementQuery *query = [self.fb_query descendantsMatchingType:type];
   NSMutableArray *result = [NSMutableArray array];
   [result addObjectsFromArray:[self.class fb_extractMatchingElementsFromQuery:query shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch]];
-  XCElementSnapshot *cachedSnapshot = [self fb_cachedSnapshotWithQuery:query];
+  id<FBXCElementSnapshot> cachedSnapshot = [self fb_cachedSnapshotWithQuery:query];
   if (type == XCUIElementTypeAny || cachedSnapshot.elementType == type) {
     if (shouldReturnAfterFirstMatch || result.count == 0) {
       return @[self];
@@ -73,7 +71,9 @@
   return elements;
 }
 
-- (void)descendantsWithProperty:(NSString *)property value:(NSString *)value partial:(BOOL)partialSearch results:(NSMutableArray<XCUIElement *> *)results
+- (void)descendantsWithProperty:(NSString *)property value:(NSString *)value
+                        partial:(BOOL)partialSearch
+                        results:(NSMutableArray<XCUIElement *> *)results
 {
   if (partialSearch) {
     NSString *text = [self fb_valueForWDAttributeName:property];
@@ -88,12 +88,12 @@
   }
 
   property = [FBElementUtils wdAttributeNameForAttributeName:property];
-  value = [value stringByReplacingOccurrencesOfString:@"'" withString:@"\\'"];
-  NSString *operation = partialSearch ?
-  [NSString stringWithFormat:@"%@ like '*%@*'", property, value] :
-  [NSString stringWithFormat:@"%@ == '%@'", property, value];
-
-  NSPredicate *predicate = [FBPredicate predicateWithFormat:operation];
+  NSPredicate *predicate = [NSPredicate predicateWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot,
+                                                                 NSDictionary<NSString *,id> * _Nullable bindings) {
+    FBXCElementSnapshotWrapper *wrappedSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:snapshot];
+    NSString *propertyValue = [NSString stringWithFormat:@"%@", [wrappedSnapshot fb_valueForWDAttributeName:property]];
+    return partialSearch ? [value containsString:propertyValue] : [value isEqualToString:propertyValue];
+  }];
   XCUIElementQuery *query = [[self.fb_query descendantsMatchingType:XCUIElementTypeAny] matchingPredicate:predicate];
   NSArray *childElements = query.fb_allMatches;
   [results addObjectsFromArray:childElements];
@@ -105,12 +105,12 @@
 - (NSArray<XCUIElement *> *)fb_descendantsMatchingPredicate:(NSPredicate *)predicate
                                 shouldReturnAfterFirstMatch:(BOOL)shouldReturnAfterFirstMatch
 {
-  NSPredicate *formattedPredicate = [NSPredicate fb_formatSearchPredicate:predicate];
+  NSPredicate *formattedPredicate = [NSPredicate fb_snapshotBlockPredicateWithPredicate:predicate];
   XCUIElementQuery *query = [[self.fb_query descendantsMatchingType:XCUIElementTypeAny] matchingPredicate:formattedPredicate];
   NSMutableArray<XCUIElement *> *result = [NSMutableArray array];
   [result addObjectsFromArray:[self.class fb_extractMatchingElementsFromQuery:query
                                                   shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch]];
-  XCElementSnapshot *cachedSnapshot = [self fb_cachedSnapshotWithQuery:query];
+  id<FBXCElementSnapshot> cachedSnapshot = [self fb_cachedSnapshotWithQuery:query];
   // Include self element into predicate search
   if ([formattedPredicate evaluateWithObject:cachedSnapshot]) {
     if (shouldReturnAfterFirstMatch || result.count == 0) {
@@ -129,16 +129,16 @@
 {
   // XPath will try to match elements only class name, so requesting elements by XCUIElementTypeAny will not work. We should use '*' instead.
   xpathQuery = [xpathQuery stringByReplacingOccurrencesOfString:@"XCUIElementTypeAny" withString:@"*"];
-  NSArray<XCElementSnapshot *> *matchingSnapshots = [FBXPath matchesWithRootElement:self forQuery:xpathQuery];
+  NSArray<id<FBXCElementSnapshot>> *matchingSnapshots = [FBXPath matchesWithRootElement:self forQuery:xpathQuery];
   if (0 == [matchingSnapshots count]) {
     return @[];
   }
   if (shouldReturnAfterFirstMatch) {
-    XCElementSnapshot *snapshot = matchingSnapshots.firstObject;
+    id<FBXCElementSnapshot> snapshot = matchingSnapshots.firstObject;
     matchingSnapshots = @[snapshot];
   }
   return [self fb_filterDescendantsWithSnapshots:matchingSnapshots
-                                         selfUID:self.lastSnapshot.wdUID
+                                         selfUID:[FBXCElementSnapshotWrapper ensureWrapped:self.lastSnapshot].wdUID
                                     onlyChildren:NO];
 }
 
@@ -148,7 +148,11 @@
 - (NSArray<XCUIElement *> *)fb_descendantsMatchingIdentifier:(NSString *)accessibilityId
                                  shouldReturnAfterFirstMatch:(BOOL)shouldReturnAfterFirstMatch
 {
-  NSPredicate *predicate = [FBPredicate predicateWithFormat:@"name == %@", accessibilityId];
+  NSPredicate *predicate = [NSPredicate predicateWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot,
+                                                                 NSDictionary<NSString *,id> * _Nullable bindings) {
+    FBXCElementSnapshotWrapper *wrappedSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:snapshot];
+    return [wrappedSnapshot.wdName isEqualToString:accessibilityId];
+  }];
   return [self fb_descendantsMatchingPredicate:predicate
                    shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch];
 }

package/WebDriverAgentLib/Categories/XCUIElement+FBIsVisible.h

@@ -7,8 +7,7 @@
  * of patent rights can be found in the PATENTS file in the same directory.
  */
 
-#import <WebDriverAgentLib/XCElementSnapshot.h>
-#import <WebDriverAgentLib/XCUIElement.h>
+#import "FBXCElementSnapshotWrapper.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -20,7 +19,7 @@ NS_ASSUME_NONNULL_BEGIN
 @end
 
 
-@interface XCElementSnapshot (FBIsVisible)
+@interface FBXCElementSnapshotWrapper (FBIsVisible)
 
 /*! Whether or not the element is visible */
 @property (atomic, readonly) BOOL fb_isVisible;

package/WebDriverAgentLib/Categories/XCUIElement+FBIsVisible.m

@@ -14,10 +14,9 @@
 #import "FBMathUtils.h"
 #import "FBActiveAppDetectionPoint.h"
 #import "FBSession.h"
+#import "FBXCAccessibilityElement.h"
 #import "FBXCodeCompatibility.h"
-#import "XCAccessibilityElement+FBComparison.h"
-#import "XCElementSnapshot+FBHelpers.h"
-#import "XCElementSnapshot+FBHitPoint.h"
+#import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "XCUIElement+FBUtilities.h"
 #import "XCUIElement+FBUID.h"
 #import "XCTestPrivateSymbols.h"
@@ -26,13 +25,14 @@
 
 - (BOOL)fb_isVisible
 {
-  return [self fb_snapshotWithAttributes:@[FB_XCAXAIsVisibleAttributeName]
-                                maxDepth:@1].fb_isVisible;
+  id<FBXCElementSnapshot> snapshot = [self fb_snapshotWithAttributes:@[FB_XCAXAIsVisibleAttributeName]
+                                                            maxDepth:@1];
+  return [FBXCElementSnapshotWrapper ensureWrapped:snapshot].fb_isVisible;
 }
 
 @end
 
-@implementation XCElementSnapshot (FBIsVisible)
+@implementation FBXCElementSnapshotWrapper (FBIsVisible)
 
 - (NSString *)fb_uniqId
 {
@@ -57,7 +57,7 @@
 }
 
 - (BOOL)fb_cacheVisibilityWithValue:(BOOL)isVisible
-                       forAncestors:(nullable NSArray<XCElementSnapshot *> *)ancestors
+                       forAncestors:(nullable NSArray<id<FBXCElementSnapshot>> *)ancestors
 {
   NSMutableDictionary *cache = FBSession.activeSession.elementsVisibilityCache;
   if (nil == cache) {
@@ -72,8 +72,8 @@
   [destination setObject:visibleObj forKey:self.fb_uniqId];
   if (isVisible && nil != ancestors) {
     // if an element is visible then all its ancestors must be visible as well
-    for (XCElementSnapshot *ancestor in ancestors) {
-      NSString *ancestorId = ancestor.fb_uniqId;
+    for (id<FBXCElementSnapshot> ancestor in ancestors) {
+      NSString *ancestorId = [FBXCElementSnapshotWrapper ensureWrapped:ancestor].fb_uniqId;
       if (nil == [destination objectForKey:ancestorId]) {
         [destination setObject:visibleObj forKey:ancestorId];
       }
@@ -82,17 +82,17 @@
   return isVisible;
 }
 
-- (CGRect)fb_frameInContainer:(XCElementSnapshot *)container
+- (CGRect)fb_frameInContainer:(id<FBXCElementSnapshot>)container
         hierarchyIntersection:(nullable NSValue *)intersectionRectange
 {
   CGRect currentRectangle = nil == intersectionRectange ? self.frame : [intersectionRectange CGRectValue];
-  XCElementSnapshot *parent = self.parent;
+  id<FBXCElementSnapshot> parent = self.parent;
   CGRect parentFrame = parent.frame;
   CGRect containerFrame = container.frame;
   if (CGSizeEqualToSize(parentFrame.size, CGSizeZero) &&
       CGPointEqualToPoint(parentFrame.origin, CGPointZero)) {
     // Special case (or XCTest bug). Shift the origin and return immediately after shift
-    XCElementSnapshot *nextParent = parent.parent;
+    id<FBXCElementSnapshot> nextParent = parent.parent;
     BOOL isGrandparent = YES;
     while (nextParent && nextParent != container) {
       CGRect nextParentFrame = nextParent.frame;
@@ -133,18 +133,19 @@
   if (CGRectIsEmpty(intersectionWithParent) || parent == container) {
     return intersectionWithParent;
   }
-  return [parent fb_frameInContainer:container hierarchyIntersection:[NSValue valueWithCGRect:intersectionWithParent]];
+  return [[FBXCElementSnapshotWrapper ensureWrapped:parent] fb_frameInContainer:container
+                                                          hierarchyIntersection:[NSValue valueWithCGRect:intersectionWithParent]];
 }
 
 - (BOOL)fb_hasAnyVisibleLeafs
 {
-  NSArray<XCElementSnapshot *> *children = self.children;
+  NSArray<id<FBXCElementSnapshot>> *children = self.children;
   if (0 == children.count) {
     return self.fb_isVisible;
   }
 
-  for (XCElementSnapshot *child in children) {
-    if (child.fb_hasAnyVisibleLeafs) {
+  for (id<FBXCElementSnapshot> child in children) {
+    if ([FBXCElementSnapshotWrapper ensureWrapped:child].fb_hasAnyVisibleLeafs) {
       return YES;
     }
   }
@@ -169,13 +170,13 @@
     return [self fb_cacheVisibilityWithValue:NO forAncestors:nil];
   }
 
-  NSArray<XCElementSnapshot *> *ancestors = self.fb_ancestors;
+  NSArray<id<FBXCElementSnapshot>> *ancestors = self.fb_ancestors;
   if ([FBConfiguration shouldUseTestManagerForVisibilityDetection]) {
     BOOL visibleAttrValue = [(NSNumber *)[self fb_attributeValue:FB_XCAXAIsVisibleAttributeName] boolValue];
     return [self fb_cacheVisibilityWithValue:visibleAttrValue forAncestors:ancestors];
   }
 
-  XCElementSnapshot *parentWindow = ancestors.count > 1 ? [ancestors objectAtIndex:ancestors.count - 2] : nil;
+  id<FBXCElementSnapshot> parentWindow = ancestors.count > 1 ? [ancestors objectAtIndex:ancestors.count - 2] : nil;
   CGRect visibleRect = selfFrame;
   if (nil != parentWindow) {
     visibleRect = [self fb_frameInContainer:parentWindow hierarchyIntersection:nil];
@@ -186,7 +187,7 @@
   CGPoint midPoint = CGPointMake(visibleRect.origin.x + visibleRect.size.width / 2,
                                  visibleRect.origin.y + visibleRect.size.height / 2);
 #if !TARGET_OS_TV // TV has no orientation, so it does not need to coordinate
-  XCElementSnapshot *appElement = ancestors.count > 0 ? [ancestors lastObject] : self;
+  id<FBXCElementSnapshot> appElement = ancestors.count > 0 ? [ancestors lastObject] : self;
   CGRect appFrame = appElement.frame;
   CGRect windowFrame = nil == parentWindow ? selfFrame : parentWindow.frame;
   if ((appFrame.size.height > appFrame.size.width && windowFrame.size.height < windowFrame.size.width) ||
@@ -197,22 +198,23 @@
     midPoint = FBInvertPointForApplication(midPoint, appFrame.size, FBApplication.fb_activeApplication.interfaceOrientation);
   }
 #endif
-  XCAccessibilityElement *hitElement = [FBActiveAppDetectionPoint axElementWithPoint:midPoint];
+  id<FBXCAccessibilityElement> hitElement = [FBActiveAppDetectionPoint axElementWithPoint:midPoint];
   if (nil != hitElement) {
-    if ([self.accessibilityElement fb_isEqualToElement:hitElement]) {
+    if (FBIsAXElementEqualToOther(self.accessibilityElement, hitElement)) {
       return [self fb_cacheVisibilityWithValue:YES forAncestors:ancestors];
     }
-    for (XCElementSnapshot *ancestor in ancestors) {
-      if ([hitElement fb_isEqualToElement:ancestor.accessibilityElement]) {
+    for (id<FBXCElementSnapshot> ancestor in ancestors) {
+      if (FBIsAXElementEqualToOther(hitElement, ancestor.accessibilityElement)) {
         return [self fb_cacheVisibilityWithValue:YES forAncestors:ancestors];
       }
     }
   }
   if (self.children.count > 0) {
     if (nil != hitElement) {
-      for (XCElementSnapshot *descendant in self._allDescendants) {
-        if ([hitElement fb_isEqualToElement:descendant.accessibilityElement]) {
-          return [self fb_cacheVisibilityWithValue:YES forAncestors:descendant.fb_ancestors];
+      for (id<FBXCElementSnapshot> descendant in self._allDescendants) {
+        if (FBIsAXElementEqualToOther(hitElement, descendant.accessibilityElement)) {
+          return [self fb_cacheVisibilityWithValue:YES
+                                      forAncestors:[FBXCElementSnapshotWrapper ensureWrapped:descendant].fb_ancestors];
         }
       }
     }

package/WebDriverAgentLib/Categories/XCUIElement+FBPickerWheel.m

@@ -10,6 +10,7 @@
 #import "XCUIElement+FBPickerWheel.h"
 
 #import "FBRunLoopSpinner.h"
+#import "FBXCElementSnapshot.h"
 #import "FBXCodeCompatibility.h"
 #import "XCUIApplication+FBTouchAction.h"
 #import "XCUICoordinate.h"
@@ -23,7 +24,7 @@ static const NSTimeInterval VALUE_CHANGE_TIMEOUT = 2;
 
 - (BOOL)fb_scrollWithOffset:(CGFloat)relativeHeightOffset error:(NSError **)error
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
   NSString *previousValue = snapshot.value;

package/WebDriverAgentLib/Categories/XCUIElement+FBResolve.m

@@ -41,11 +41,15 @@ static char XCUIELEMENT_IS_RESOLVED_NATIVELY_KEY;
   XCUIElementQuery *query = [self isKindOfClass:XCUIApplication.class]
     ? self.application.fb_query
     : [self.application.fb_query descendantsMatchingType:XCUIElementTypeAny];
-  XCElementSnapshot *cachedSnapshot = self.fb_cachedSnapshot;
+  FBXCElementSnapshotWrapper *cachedSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:self.fb_cachedSnapshot];
   NSString *uid = nil == cachedSnapshot ? self.fb_uid : cachedSnapshot.fb_uid;
-  return nil == uid
-    ? self
-    : [query matchingPredicate:[NSPredicate predicateWithFormat:@"%K = %@", FBStringify(XCUIElement, wdUID), uid]].fb_firstMatch;
+  if (nil == uid) {
+    return self;
+  }
+  NSPredicate *predicate = [NSPredicate predicateWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot, NSDictionary *bindings) {
+    return [[FBXCElementSnapshotWrapper ensureWrapped:snapshot].fb_uid isEqualToString:uid];
+  }];
+  return (XCUIElement *)[query matchingPredicate:predicate].fb_firstMatch;
 }
 
 @end

package/WebDriverAgentLib/Categories/XCUIElement+FBScrolling.h

@@ -60,6 +60,16 @@ typedef NS_ENUM(NSUInteger, FBXCUIElementScrollDirection) {
  */
 - (BOOL)fb_scrollToVisibleWithError:(NSError **)error;
 
+/**
+ Scrolls parent scroll view till the current element is visible.
+ This call is fast as it uses a native XCTest implementation.
+ The element must be hittable.
+
+ @param error If there is an error, upon return contains an NSError object that describes the problem.
+ @return YES if the operation succeeds, otherwise NO.
+ */
+- (BOOL)fb_nativeScrollToVisibleWithError:(NSError **)error;
+
 /**
  Scrolls parent scroll view till receiver is visible. Whenever element is invisible it scrolls by normalizedScrollDistance
  in its direction. E.g. if normalizedScrollDistance is equal to 0.5, each step will scroll by half of scroll view's size.

package/WebDriverAgentLib/Categories/XCUIElement+FBScrolling.m

@@ -13,12 +13,11 @@
 #import "FBLogger.h"
 #import "FBMacros.h"
 #import "FBMathUtils.h"
-#import "FBPredicate.h"
 #import "FBXCodeCompatibility.h"
+#import "FBXCElementSnapshotWrapper.h"
+#import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "XCUIApplication+FBTouchAction.h"
 #import "XCUIElement+FBCaching.h"
-#import "XCElementSnapshot+FBHelpers.h"
-#import "XCElementSnapshot.h"
 #import "XCUIApplication.h"
 #import "XCUICoordinate.h"
 #import "XCUICoordinate+FBFix.h"
@@ -34,7 +33,7 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 
 #if !TARGET_OS_TV
 
-@interface XCElementSnapshot (FBScrolling)
+@interface FBXCElementSnapshotWrapper (FBScrolling)
 
 - (void)fb_scrollUpByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
 - (void)fb_scrollDownByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
@@ -47,36 +46,49 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 
 @implementation XCUIElement (FBScrolling)
 
+- (BOOL)fb_nativeScrollToVisibleWithError:(NSError **)error
+{
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
+    ? self.lastSnapshot
+    : self.fb_takeSnapshot;
+  return nil != [self _hitPointByAttemptingToScrollToVisibleSnapshot:snapshot
+                                                               error:error];
+}
+
 - (void)fb_scrollUpByNormalizedDistance:(CGFloat)distance
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
-  [snapshot fb_scrollUpByNormalizedDistance:distance inApplication:self.application];
+  [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollUpByNormalizedDistance:distance
+                                                                         inApplication:self.application];
 }
 
 - (void)fb_scrollDownByNormalizedDistance:(CGFloat)distance
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
-  [snapshot fb_scrollDownByNormalizedDistance:distance inApplication:self.application];
+  [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollDownByNormalizedDistance:distance
+                                                                           inApplication:self.application];
 }
 
 - (void)fb_scrollLeftByNormalizedDistance:(CGFloat)distance
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
-  [snapshot fb_scrollLeftByNormalizedDistance:distance inApplication:self.application];
+  [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollLeftByNormalizedDistance:distance
+                                                                           inApplication:self.application];
 }
 
 - (void)fb_scrollRightByNormalizedDistance:(CGFloat)distance
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
-  [snapshot fb_scrollRightByNormalizedDistance:distance inApplication:self.application];
+  [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollRightByNormalizedDistance:distance
+                                                                            inApplication:self.application];
 }
 
 - (BOOL)fb_scrollToVisibleWithError:(NSError **)error
@@ -91,9 +103,11 @@ const CGFloat FBScrollTouchProportion = 0.75f;
                                                         error:error];
 }
 
-- (BOOL)fb_scrollToVisibleWithNormalizedScrollDistance:(CGFloat)normalizedScrollDistance scrollDirection:(FBXCUIElementScrollDirection)scrollDirection error:(NSError **)error
+- (BOOL)fb_scrollToVisibleWithNormalizedScrollDistance:(CGFloat)normalizedScrollDistance
+                                       scrollDirection:(FBXCUIElementScrollDirection)scrollDirection
+                                                 error:(NSError **)error
 {
-  XCElementSnapshot *prescrollSnapshot = [self fb_takeSnapshot];
+  FBXCElementSnapshotWrapper *prescrollSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:[self fb_takeSnapshot]];
   if (prescrollSnapshot.isWDVisible) {
     return YES;
   }
@@ -109,23 +123,30 @@ const CGFloat FBScrollTouchProportion = 0.75f;
     ];
   });
 
-  __block NSArray<XCElementSnapshot *> *cellSnapshots, *visibleCellSnapshots;
-  XCElementSnapshot *scrollView = [prescrollSnapshot fb_parentMatchingOneOfTypes:acceptedParents
-      filter:^(XCElementSnapshot *snapshot) {
-
-         if (![snapshot isWDVisible]) {
-           return NO;
-         }
-
-         cellSnapshots = [snapshot fb_descendantsCellSnapshots];
+  __block NSArray<id<FBXCElementSnapshot>> *cellSnapshots;
+  __block NSMutableArray<id<FBXCElementSnapshot>> *visibleCellSnapshots = [NSMutableArray new];
+  id<FBXCElementSnapshot> scrollView = [prescrollSnapshot fb_parentMatchingOneOfTypes:acceptedParents
+      filter:^(id<FBXCElementSnapshot> snapshot) {
+    FBXCElementSnapshotWrapper *wrappedSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:snapshot];
+    
+    if (![wrappedSnapshot isWDVisible]) {
+      return NO;
+    }
 
-         visibleCellSnapshots = [cellSnapshots filteredArrayUsingPredicate:[FBPredicate predicateWithFormat:@"%K == YES", FBStringify(XCUIElement, fb_isVisible)]];
+    cellSnapshots = [wrappedSnapshot fb_descendantsCellSnapshots];
+    
+    for (id<FBXCElementSnapshot> cellSnapshot in cellSnapshots) {
+      FBXCElementSnapshotWrapper *wrappedCellSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:cellSnapshot];
+      if (wrappedCellSnapshot.wdVisible) {
+        [visibleCellSnapshots addObject:cellSnapshot];
+      }
+    }
 
-         if (visibleCellSnapshots.count > 1) {
-           return YES;
-         }
-         return NO;
-      }];
+    if (visibleCellSnapshots.count > 1) {
+      return YES;
+    }
+    return NO;
+  }];
 
   if (scrollView == nil) {
     return
@@ -134,20 +155,21 @@ const CGFloat FBScrollTouchProportion = 0.75f;
      buildError:error];
   }
 
-  XCElementSnapshot *targetCellSnapshot = [prescrollSnapshot fb_parentCellSnapshot];
-  XCElementSnapshot *lastSnapshot = visibleCellSnapshots.lastObject;
+  id<FBXCElementSnapshot> targetCellSnapshot = [prescrollSnapshot fb_parentCellSnapshot];
+  id<FBXCElementSnapshot> lastSnapshot = visibleCellSnapshots.lastObject;
   // Can't just do indexOfObject, because targetCellSnapshot may represent the same object represented by a member of cellSnapshots, yet be a different object
   // than that member. This reflects the fact that targetCellSnapshot came out of self.fb_parentCellSnapshot, not out of cellSnapshots directly.
   // If the result is NSNotFound, we'll just proceed by scrolling downward/rightward, since NSNotFound will always be larger than the current index.
-  NSUInteger targetCellIndex = [cellSnapshots indexOfObjectPassingTest:^BOOL(XCElementSnapshot *_Nonnull obj, NSUInteger idx, BOOL *_Nonnull stop) {
+  NSUInteger targetCellIndex = [cellSnapshots indexOfObjectPassingTest:^BOOL(id<FBXCElementSnapshot> _Nonnull obj,
+                                                                             NSUInteger idx, BOOL *_Nonnull stop) {
     return [obj _matchesElement:targetCellSnapshot];
   }];
   NSUInteger visibleCellIndex = [cellSnapshots indexOfObject:lastSnapshot];
 
   if (scrollDirection == FBXCUIElementScrollDirectionUnknown) {
     // Try to determine the scroll direction by determining the vector between the first and last visible cells
-    XCElementSnapshot *firstVisibleCell = visibleCellSnapshots.firstObject;
-    XCElementSnapshot *lastVisibleCell = visibleCellSnapshots.lastObject;
+    id<FBXCElementSnapshot> firstVisibleCell = visibleCellSnapshots.firstObject;
+    id<FBXCElementSnapshot> lastVisibleCell = visibleCellSnapshots.lastObject;
     CGVector cellGrowthVector = CGVectorMake(firstVisibleCell.frame.origin.x - lastVisibleCell.frame.origin.x,
                                              firstVisibleCell.frame.origin.y - lastVisibleCell.frame.origin.y
                                              );
@@ -160,17 +182,22 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 
   const NSUInteger maxScrollCount = 25;
   NSUInteger scrollCount = 0;
+  FBXCElementSnapshotWrapper *scrollViewWrapped = [FBXCElementSnapshotWrapper ensureWrapped:scrollView];
   // Scrolling till cell is visible and get current value of frames
   while (![self fb_isEquivalentElementSnapshotVisible:prescrollSnapshot] && scrollCount < maxScrollCount) {
     if (targetCellIndex < visibleCellIndex) {
       scrollDirection == FBXCUIElementScrollDirectionVertical ?
-        [scrollView fb_scrollUpByNormalizedDistance:normalizedScrollDistance inApplication:self.application] :
-        [scrollView fb_scrollLeftByNormalizedDistance:normalizedScrollDistance inApplication:self.application];
+        [scrollViewWrapped fb_scrollUpByNormalizedDistance:normalizedScrollDistance
+                                             inApplication:self.application] :
+        [scrollViewWrapped fb_scrollLeftByNormalizedDistance:normalizedScrollDistance
+                                               inApplication:self.application];
     }
     else {
       scrollDirection == FBXCUIElementScrollDirectionVertical ?
-        [scrollView fb_scrollDownByNormalizedDistance:normalizedScrollDistance inApplication:self.application] :
-        [scrollView fb_scrollRightByNormalizedDistance:normalizedScrollDistance inApplication:self.application];
+        [scrollViewWrapped fb_scrollDownByNormalizedDistance:normalizedScrollDistance
+                                               inApplication:self.application] :
+        [scrollViewWrapped fb_scrollRightByNormalizedDistance:normalizedScrollDistance
+                                                inApplication:self.application];
     }
     scrollCount++;
     // Wait for scroll animation
@@ -187,28 +214,32 @@ const CGFloat FBScrollTouchProportion = 0.75f;
   // Cell is now visible, but it might be only partialy visible, scrolling till whole frame is visible.
   // Sometimes, attempting to grab the parent snapshot of the target cell after scrolling is complete causes a stale element reference exception.
   // Trying fb_cachedSnapshot first
-  targetCellSnapshot = [([self fb_cachedSnapshot] ?: [self fb_takeSnapshot]) fb_parentCellSnapshot];
-  CGRect visibleFrame = targetCellSnapshot.fb_visibleFrameWithFallback;
+  FBXCElementSnapshotWrapper *targetCellSnapshotWrapped = [FBXCElementSnapshotWrapper ensureWrapped:([self fb_cachedSnapshot] ?: [self fb_takeSnapshot])];
+  targetCellSnapshot = [targetCellSnapshotWrapped fb_parentCellSnapshot];
+  CGRect visibleFrame = [FBXCElementSnapshotWrapper ensureWrapped:targetCellSnapshot].fb_visibleFrameWithFallback;
   
   CGVector scrollVector = CGVectorMake(visibleFrame.size.width - targetCellSnapshot.frame.size.width,
                                        visibleFrame.size.height - targetCellSnapshot.frame.size.height
                                        );
-  if (![scrollView fb_scrollByVector:scrollVector inApplication:self.application error:error]) {
-    return NO;
-  }
-  return YES;
+  return [scrollViewWrapped fb_scrollByVector:scrollVector
+                                inApplication:self.application
+                                        error:error];
 }
 
-- (BOOL)fb_isEquivalentElementSnapshotVisible:(XCElementSnapshot *)snapshot
+- (BOOL)fb_isEquivalentElementSnapshotVisible:(id<FBXCElementSnapshot>)snapshot
 {
-  if (snapshot.isWDVisible) {
+  FBXCElementSnapshotWrapper *wrappedSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:snapshot];
+  
+  if (wrappedSnapshot.isWDVisible) {
     return YES;
   }
 
-  XCElementSnapshot *appSnapshot = [self.application fb_takeSnapshot];
-  for (XCElementSnapshot *elementSnapshot in appSnapshot._allDescendants.copy) {
+  id<FBXCElementSnapshot> appSnapshot = [self.application fb_takeSnapshot];
+  for (id<FBXCElementSnapshot> elementSnapshot in appSnapshot._allDescendants.copy) {
+    FBXCElementSnapshotWrapper *wrappedElementSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:elementSnapshot];
     // We are comparing pre-scroll snapshot so frames are irrelevant.
-    if ([snapshot fb_framelessFuzzyMatchesElement:elementSnapshot] && elementSnapshot.isWDVisible) {
+    if ([wrappedSnapshot fb_framelessFuzzyMatchesElement:elementSnapshot]
+        && wrappedElementSnapshot.isWDVisible) {
       return YES;
     }
   }
@@ -218,7 +249,7 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 @end
 
 
-@implementation XCElementSnapshot (FBScrolling)
+@implementation FBXCElementSnapshotWrapper (FBScrolling)
 
 - (CGRect)scrollingFrame
 {