GREYMatchers.js

/**

	This code is generated.
	For more information see generation/README.md.
*/


function sanitize_uiAccessibilityTraits(value) {
  let traits = 0;
  for (let i = 0; i < value.length; i++) {
    switch (value[i]) {
      case 'button':
        traits |= 1;
        break;
      case 'link':
        traits |= 2;
        break;
      case 'header':
        traits |= 4;
        break;
      case 'search':
        traits |= 8;
        break;
      case 'image':
        traits |= 16;
        break;
      case 'selected':
        traits |= 32;
        break;
      case 'plays':
        traits |= 64;
        break;
      case 'key':
        traits |= 128;
        break;
      case 'text':
        traits |= 256;
        break;
      case 'summary':
        traits |= 512;
        break;
      case 'disabled':
        traits |= 1024;
        break;
      case 'frequentUpdates':
        traits |= 2048;
        break;
      case 'startsMedia':
        traits |= 4096;
        break;
      case 'adjustable':
        traits |= 8192;
        break;
      case 'allowsDirectInteraction':
        traits |= 16384;
        break;
      case 'pageTurn':
        traits |= 32768;
        break;
      default:
        throw new Error(
          `Unknown trait '${value[i]}', see list in https://facebook.github.io/react-native/docs/accessibility.html#accessibilitytraits-ios`
        );
    }
  }

  return traits;
} 
function sanitize_greyContentEdge(action) {
  switch (action) {
    case 'left':
      return 0;
    case 'right':
      return 1;
    case 'top':
      return 2;
    case 'bottom':
      return 3;

    default:
      throw new Error(`GREYAction.GREYContentEdge must be a 'left'/'right'/'top'/'bottom', got ${action}`);
  }
} 
class GREYMatchers {
  /*Matcher for application's key window.
  
  @return A matcher for the application's key window.*/
  static matcherForKeyWindow() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForKeyWindow",
      args: []
    };
  }

  /*Matcher for UI element with the provided accessibility @c label.
  
  @param label The accessibility label to be matched.
  
  @return A matcher for the accessibility label of an accessible element.*/
  static matcherForAccessibilityLabel(label) {
    if (typeof label !== "string") throw new Error("label should be a string, but got " + (label + (" (" + (typeof label + ")"))));
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForAccessibilityLabel:",
      args: [{
        type: "NSString",
        value: label
      }]
    };
  }

  /*Matcher for UI element with the provided accessibility ID @c accessibilityID.
  
  @param accessibilityID The accessibility ID to be matched.
  
  @return A matcher for the accessibility ID of an accessible element.*/
  static matcherForAccessibilityID(accessibilityID) {
    if (typeof accessibilityID !== "string") throw new Error("accessibilityID should be a string, but got " + (accessibilityID + (" (" + (typeof accessibilityID + ")"))));
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForAccessibilityID:",
      args: [{
        type: "NSString",
        value: accessibilityID
      }]
    };
  }

  /*Matcher for UI element with the provided accessibility @c value.
  
  @param value The accessibility value to be matched.
  
  @return A matcher for the accessibility value of an accessible element.*/
  static matcherForAccessibilityValue(value) {
    if (typeof value !== "string") throw new Error("value should be a string, but got " + (value + (" (" + (typeof value + ")"))));
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForAccessibilityValue:",
      args: [{
        type: "NSString",
        value: value
      }]
    };
  }

  /*Matcher for UI element with the provided accessibility @c traits.
  
  @param traits The accessibility traits to be matched.
  
  @return A matcher for the accessibility traits of an accessible element.
  */
  static matcherForAccessibilityTraits(traits) {
    if (typeof traits !== 'object' || !traits instanceof Array) {
      throw new Error('traits must be an array, got ' + typeof traits);
    }

    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForAccessibilityTraits:",
      args: [{
        type: "NSInteger",
        value: sanitize_uiAccessibilityTraits(traits)
      }]
    };
  }

  /*Matcher for UI element with the provided accessiblity @c hint.
  
  @param hint The accessibility hint to be matched.
  
  @return A matcher for the accessibility hint of an accessible element.*/
  static matcherForAccessibilityHint(hint) {
    if (typeof hint !== "string") throw new Error("hint should be a string, but got " + (hint + (" (" + (typeof hint + ")"))));
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForAccessibilityHint:",
      args: [{
        type: "NSString",
        value: hint
      }]
    };
  }

  /*Matcher for UI element with accessiblity focus.
  
  @return A matcher for the accessibility focus of an accessible element.*/
  static matcherForAccessibilityElementIsFocused() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForAccessibilityElementIsFocused",
      args: []
    };
  }

  /*Matcher for UI elements of type UIButton, UILabel, UITextField or UITextView displaying the
  provided @c inputText.
  
  @param text The text to be matched in the UI elements.
  
  @return A matcher to check for any UI elements with a text field containing the given text.*/
  static matcherForText(text) {
    if (typeof text !== "string") throw new Error("text should be a string, but got " + (text + (" (" + (typeof text + ")"))));
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForText:",
      args: [{
        type: "NSString",
        value: text
      }]
    };
  }

  /*Matcher for element that is the first responder.
  
  @return A matcher that verifies if a UI element is the first responder.*/
  static matcherForFirstResponder() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForFirstResponder",
      args: []
    };
  }

  /*Matcher to check if system alert view is shown.
  
  @return A matcher to check if a system alert view is being shown.*/
  static matcherForSystemAlertViewShown() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForSystemAlertViewShown",
      args: []
    };
  }

  /*Matcher for UI element whose percent visible area (of its accessibility frame) exceeds the
  given @c percent.
  
  @param percent The percent visible area that the UI element being matched has to be visible.
  Allowed values for @c percent are [0,1] inclusive.
  
  @return A matcher that checks if a UI element has a visible area at least equal
  to a minimum value.*/
  static matcherForMinimumVisiblePercent(percent) {
    if (typeof percent !== "number") throw new Error("percent should be a number, but got " + (percent + (" (" + (typeof percent + ")"))));
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForMinimumVisiblePercent:",
      args: [{
        type: "CGFloat",
        value: percent
      }]
    };
  }

  /*Matcher for UI element that is sufficiently visible to the user. EarlGrey considers elements
  that are more than @c kElementSufficientlyVisiblePercentage (75 %) visible areawise to be
  sufficiently visible.
  
  @return A matcher intialized with a visibility percentage that confirms an element is
  sufficiently visible.*/
  static matcherForSufficientlyVisible() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForSufficientlyVisible",
      args: []
    };
  }

  /*Matcher for UI element that is not visible to the user at all i.e. it has a zero visible area.
  
  @return A matcher for verifying if an element is not visible.*/
  static matcherForNotVisible() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForNotVisible",
      args: []
    };
  }

  /*Matcher for UI element that matches EarlGrey's criteria for user interaction. Currently it must
  satisfy at least the following criteria:
  1) At least a few pixels of the element are visible to the user.
  2) The element's accessibility activation point OR the center of the element's visible area
  is completely visible.
  
  @return A matcher that checks if a UI element is interactable.*/
  static matcherForInteractable() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForInteractable",
      args: []
    };
  }

  /*Matcher to check if a UI element is accessible.
  
  @return A matcher that checks if a UI element is accessible.*/
  static matcherForAccessibilityElement() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForAccessibilityElement",
      args: []
    };
  }

  /*Matcher for matching UIProgressView's values. Use greaterThan, greaterThanOrEqualTo,
  lessThan etc to create @c comparisonMatcher. For example, to match the UIProgressView
  elements that have progress value greater than 50.2, use
  @code [GREYMatchers matcherForProgress:grey_greaterThan(@(50.2))] @endcode. In case if an
  unimplemented matcher is required, please implement it similar to @c grey_closeTo.
  
  @param comparisonMatcher The matcher with the value to check the progress against.
  
  @return A matcher for checking a UIProgessView's value.*/
  static matcherForProgress(comparisonMatcher) {
    if (typeof comparisonMatcher !== "object" || comparisonMatcher.type !== "Invocation" || typeof comparisonMatcher.value !== "object" || typeof comparisonMatcher.value.target !== "object" || comparisonMatcher.value.target.value !== "GREYMatchers") {
      throw new Error('comparisonMatcher should be a GREYMatcher, but got ' + JSON.stringify(comparisonMatcher));
    }

    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForProgress:",
      args: [comparisonMatcher]
    };
  }

  /*Matcher that matches any UI element with an ancestor matching the given @c ancestorMatcher.
  
  @param ancestorMatcher A matcher that's run against the ancestors of the UI element being
  matched.
  
  @return A matcher to check if a specified element has an ancestor that matches
  @c ancestorMatcher.*/
  static matcherForAncestor(ancestorMatcher) {
    if (typeof ancestorMatcher !== "object" || ancestorMatcher.type !== "Invocation" || typeof ancestorMatcher.value !== "object" || typeof ancestorMatcher.value.target !== "object" || ancestorMatcher.value.target.value !== "GREYMatchers") {
      throw new Error('ancestorMatcher should be a GREYMatcher, but got ' + JSON.stringify(ancestorMatcher));
    }

    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForAncestor:",
      args: [ancestorMatcher]
    };
  }

  /*Matcher that matches any UI element with a descendant matching the given @c descendantMatcher.
  
  @param descendantMatcher A matcher that's run against the descendants of the UI element being
  matched.
  
  @return A matcher to check if a specified element has a descendant that matches
  @c descendantMatcher.*/
  static matcherForDescendant(descendantMatcher) {
    if (typeof descendantMatcher !== "object" || descendantMatcher.type !== "Invocation" || typeof descendantMatcher.value !== "object" || typeof descendantMatcher.value.target !== "object" || descendantMatcher.value.target.value !== "GREYMatchers") {
      throw new Error('descendantMatcher should be a GREYMatcher, but got ' + JSON.stringify(descendantMatcher));
    }

    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForDescendant:",
      args: [descendantMatcher]
    };
  }

  /*Matcher that matches UIButton that has title label as @c text.
  
  @param title The title to be checked on the UIButtons being matched.
  
  @return A matcher to confirm UIButton titles.*/
  static matcherForButtonTitle(title) {
    if (typeof title !== "string") throw new Error("title should be a string, but got " + (title + (" (" + (typeof title + ")"))));
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForButtonTitle:",
      args: [{
        type: "NSString",
        value: title
      }]
    };
  }

  /*Matcher that matches UIScrollView that has contentOffset as @c offset.
  
  @param offset The content offset to be checked on the UIScrollView being
  matched.
  
  @return A matcher to confirm UIScrollView content offset.*/
  static matcherForScrollViewContentOffset(offset) {
    if (typeof offset !== "object") throw new Error("offset should be a object, but got " + (offset + (" (" + (typeof offset + ")"))));
    if (typeof offset.x !== "number") throw new Error("offset.x should be a number, but got " + (offset.x + (" (" + (typeof offset.x + ")"))));
    if (typeof offset.y !== "number") throw new Error("offset.y should be a number, but got " + (offset.y + (" (" + (typeof offset.y + ")"))));
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForScrollViewContentOffset:",
      args: [{
        type: "CGPoint",
        value: offset
      }]
    };
  }

  /*Matcher that matches a UISlider's value.
  
  @param valueMatcher A matcher for the UISlider's value. You must provide a valid
  @c valueMatcher for the floating point value comparison. The
  @c valueMatcher should be of the type @c closeTo, @c greaterThan,
  @c lessThan, @c lessThanOrEqualTo, @c greaterThanOrEqualTo. The
  value matchers should account for any loss in precision for the given
  floating point value. If you are using @c grey_closeTo, use delta diff as
  @c kGREYAcceptableFloatDifference. In case if an unimplemented matcher
  is required, please implement it similar to @c grey_closeTo.
  
  @return A matcher for checking a UISlider's value.*/
  static matcherForSliderValueMatcher(valueMatcher) {
    if (typeof valueMatcher !== "object" || valueMatcher.type !== "Invocation" || typeof valueMatcher.value !== "object" || typeof valueMatcher.value.target !== "object" || valueMatcher.value.target.value !== "GREYMatchers") {
      throw new Error('valueMatcher should be a GREYMatcher, but got ' + JSON.stringify(valueMatcher));
    }

    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForSliderValueMatcher:",
      args: [valueMatcher]
    };
  }

  /*Matcher that verifies whether an element, that is a UIControl, is enabled.
  
  @return A matcher for checking whether a UI element is an enabled UIControl.*/
  static matcherForEnabledElement() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForEnabledElement",
      args: []
    };
  }

  /*Matcher that verifies whether an element, that is a UIControl, is selected.
  
  @return A matcher for checking whether a UI element is a selected UIControl.*/
  static matcherForSelectedElement() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForSelectedElement",
      args: []
    };
  }

  /*Matcher that verifies whether a view has its userInteractionEnabled property set to @c YES.
  
  @return A matcher for checking whether a view' userInteractionEnabled property is set to @c YES.*/
  static matcherForUserInteractionEnabled() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForUserInteractionEnabled",
      args: []
    };
  }

  /*Matcher primarily for asserting that the element is @c nil or not found.
  
  @return A matcher to check if a specified element is @c nil or not found.*/
  static matcherForNil() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForNil",
      args: []
    };
  }

  /*Matcher for asserting that the element exists in the UI hierarchy (i.e. not @c nil).
  
  @return A matcher to check if a specified element is not @c nil.*/
  static matcherForNotNil() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForNotNil",
      args: []
    };
  }

  /*A Matcher that matches against any object, including @c nils.
  
  @return A matcher that matches any object.*/
  static matcherForAnything() {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForAnything",
      args: []
    };
  }

  /*A Matcher that checks if a provided object is equal to the specified @c value. The equality is
  determined by calling the @c isEqual: method of the object being examined. In case the @c
  value is @c nil, then the object itself is checked to be @c nil.
  
  @param value  The value to be checked for equality. Please ensure that scalar types are
  passed in as boxed (object) values.
  
  @return A matcher that checks if an object is equal to the provided one.*/
  static matcherForEqualTo(value) {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForEqualTo:",
      args: [value]
    };
  }

  /*A Matcher that checks if a provided object is less than a specified @c value. The comparison
  is made by calling the @c compare: method of the object being examined.
  
  @param value The value to be compared, which should return @c NSOrderedDescending. Please
  ensure that scalar values are passed in as boxed (object) values.
  
  @return A matcher that checks an object is lesser than another provided @c value.*/
  static matcherForLessThan(value) {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForLessThan:",
      args: [value]
    };
  }

  /*A Matcher that checks if a provided object is greater than a specified @c value. The comparison
  is made by calling the @c compare: method of the object being examined.
  
  @param value The value to be compared, which should return @c NSOrderedAscending. Please
  ensure that scalar values are passed in as boxed (object) values.
  
  @return A matcher that checks an object is greater than another provided @c value.*/
  static matcherForGreaterThan(value) {
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForGreaterThan:",
      args: [value]
    };
  }

  /*Matcher that matches a UIScrollView scrolled to content @c edge.
  
  @param edge The content edge UIScrollView should be scrolled to.
  
  @return A matcher that matches a UIScrollView scrolled to content @c edge.*/
  static matcherForScrolledToContentEdge(edge) {
    if (!["left", "right", "top", "bottom"].some(option => option === edge)) throw new Error("edge should be one of [left, right, top, bottom], but got " + edge);
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForScrolledToContentEdge:",
      args: [{
        type: "NSInteger",
        value: sanitize_greyContentEdge(edge)
      }]
    };
  }

  /*Matcher that matches a UITextField's content.
  
  @param value The text string contained inside the UITextField.
  
  @return A matcher that matches the value inside a UITextField.*/
  static matcherForTextFieldValue(value) {
    if (typeof value !== "string") throw new Error("value should be a string, but got " + (value + (" (" + (typeof value + ")"))));
    return {
      target: {
        type: "Class",
        value: "GREYMatchers"
      },
      method: "matcherForTextFieldValue:",
      args: [{
        type: "NSString",
        value: value
      }]
    };
  }

}

module.exports = GREYMatchers;