diff options
author | Kevin Jin <kjin@google.com> | 2015-02-20 09:35:39 -0800 |
---|---|---|
committer | Kevin Jin <kjin@google.com> | 2015-02-20 14:37:53 -0800 |
commit | 4b31201b5a2dbf8036da5a8d089a68a39cc1dc44 (patch) | |
tree | 0a4a6d976ca45f3b87433927d57d50cb3cd51b41 /src/io/appium/droiddriver/finders/Predicates.java | |
parent | 85a1731f32032690e528a6ca1084aa148200569b (diff) | |
download | droiddriver-4b31201b5a2dbf8036da5a8d089a68a39cc1dc44.tar.gz |
rename package 'com.google.android' to 'io.appium'
Change-Id: I2c7c96cd6a6971806e2ea7b06cd6c2c6666e4340
Diffstat (limited to 'src/io/appium/droiddriver/finders/Predicates.java')
-rw-r--r-- | src/io/appium/droiddriver/finders/Predicates.java | 321 |
1 files changed, 321 insertions, 0 deletions
diff --git a/src/io/appium/droiddriver/finders/Predicates.java b/src/io/appium/droiddriver/finders/Predicates.java new file mode 100644 index 0000000..1b9ad80 --- /dev/null +++ b/src/io/appium/droiddriver/finders/Predicates.java @@ -0,0 +1,321 @@ +/* + * Copyright (C) 2013 DroidDriver committers + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.appium.droiddriver.finders; + +import android.text.TextUtils; + +import io.appium.droiddriver.UiElement; + +/** + * Static utility methods pertaining to {@code Predicate} instances. + */ +public final class Predicates { + private Predicates() {} + + private static final Predicate<Object> ANY = new Predicate<Object>() { + @Override + public boolean apply(Object o) { + return true; + } + + @Override + public String toString() { + return "any"; + } + }; + + /** + * Returns a predicate that always evaluates to {@code true}. + */ + @SuppressWarnings("unchecked") + public static <T> Predicate<T> any() { + return (Predicate<T>) ANY; + } + + /** + * Returns a predicate that is the negation of the provided {@code predicate}. + */ + public static <T> Predicate<T> not(final Predicate<T> predicate) { + return new Predicate<T>() { + @Override + public boolean apply(T input) { + return !predicate.apply(input); + } + + @Override + public String toString() { + return "not(" + predicate + ")"; + } + }; + } + + /** + * Returns a predicate that evaluates to {@code true} if both arguments + * evaluate to {@code true}. The arguments are evaluated in order, and + * evaluation will be "short-circuited" as soon as a false predicate is found. + */ + @SuppressWarnings("unchecked") + public static <T> Predicate<T> allOf(final Predicate<? super T> first, + final Predicate<? super T> second) { + if (first == null || first == ANY) { + return (Predicate<T>) second; + } + if (second == null || second == ANY) { + return (Predicate<T>) first; + } + + return new Predicate<T>() { + @Override + public boolean apply(T input) { + return first.apply(input) && second.apply(input); + } + + @Override + public String toString() { + return "allOf(" + first + ", " + second + ")"; + } + }; + } + + /** + * Returns a predicate that evaluates to {@code true} if each of its + * components evaluates to {@code true}. The components are evaluated in + * order, and evaluation will be "short-circuited" as soon as a false + * predicate is found. + */ + @SuppressWarnings("unchecked") + public static <T> Predicate<T> allOf(final Predicate<? super T>... components) { + return new Predicate<T>() { + @Override + public boolean apply(T input) { + for (Predicate<? super T> each : components) { + if (!each.apply(input)) { + return false; + } + } + return true; + } + + @Override + public String toString() { + return "allOf(" + TextUtils.join(", ", components) + ")"; + } + }; + } + + /** + * Returns a predicate that evaluates to {@code true} if any one of its + * components evaluates to {@code true}. The components are evaluated in + * order, and evaluation will be "short-circuited" as soon as a true predicate + * is found. + */ + @SuppressWarnings("unchecked") + public static <T> Predicate<T> anyOf(final Predicate<? super T>... components) { + return new Predicate<T>() { + @Override + public boolean apply(T input) { + for (Predicate<? super T> each : components) { + if (each.apply(input)) { + return true; + } + } + return false; + } + + @Override + public String toString() { + return "anyOf(" + TextUtils.join(", ", components) + ")"; + } + }; + } + + /** + * Returns a predicate that evaluates to {@code true} on a {@link UiElement} + * if its {@code attribute} is {@code true}. + */ + public static Predicate<UiElement> attributeTrue(final Attribute attribute) { + return new Predicate<UiElement>() { + @Override + public boolean apply(UiElement element) { + Boolean actual = element.get(attribute); + return actual != null && actual; + } + + @Override + public String toString() { + return String.format("{%s}", attribute); + } + }; + } + + /** + * Returns a predicate that evaluates to {@code true} on a {@link UiElement} + * if its {@code attribute} is {@code false}. + */ + public static Predicate<UiElement> attributeFalse(final Attribute attribute) { + return new Predicate<UiElement>() { + @Override + public boolean apply(UiElement element) { + Boolean actual = element.get(attribute); + return actual == null || !actual; + } + + @Override + public String toString() { + return String.format("{not %s}", attribute); + } + }; + } + + /** + * Returns a predicate that evaluates to {@code true} on a {@link UiElement} + * if its {@code attribute} equals {@code expected}. + */ + public static Predicate<UiElement> attributeEquals(final Attribute attribute, + final Object expected) { + return new Predicate<UiElement>() { + @Override + public boolean apply(UiElement element) { + Object actual = element.get(attribute); + return actual == expected || (actual != null && actual.equals(expected)); + } + + @Override + public String toString() { + return String.format("{%s=%s}", attribute, expected); + } + }; + } + + /** + * Returns a predicate that evaluates to {@code true} on a {@link UiElement} + * if its {@code attribute} matches {@code regex}. + */ + public static Predicate<UiElement> attributeMatches(final Attribute attribute, final String regex) { + return new Predicate<UiElement>() { + @Override + public boolean apply(UiElement element) { + String actual = element.get(attribute); + return actual != null && actual.matches(regex); + } + + @Override + public String toString() { + return String.format("{%s matches %s}", attribute, regex); + } + }; + } + + /** + * Returns a predicate that evaluates to {@code true} on a {@link UiElement} + * if its {@code attribute} contains {@code substring}. + */ + public static Predicate<UiElement> attributeContains(final Attribute attribute, + final String substring) { + return new Predicate<UiElement>() { + @Override + public boolean apply(UiElement element) { + String actual = element.get(attribute); + return actual != null && actual.contains(substring); + } + + @Override + public String toString() { + return String.format("{%s contains %s}", attribute, substring); + } + }; + } + + public static Predicate<UiElement> withParent(final Predicate<? super UiElement> parentPredicate) { + return new Predicate<UiElement>() { + @Override + public boolean apply(UiElement element) { + UiElement parent = element.getParent(); + return parent != null && parentPredicate.apply(parent); + } + + @Override + public String toString() { + return "withParent(" + parentPredicate + ")"; + } + }; + } + + public static Predicate<UiElement> withAncestor( + final Predicate<? super UiElement> ancestorPredicate) { + return new Predicate<UiElement>() { + @Override + public boolean apply(UiElement element) { + UiElement parent = element.getParent(); + while (parent != null) { + if (ancestorPredicate.apply(parent)) { + return true; + } + parent = parent.getParent(); + } + return false; + } + + @Override + public String toString() { + return "withAncestor(" + ancestorPredicate + ")"; + } + }; + } + + public static Predicate<UiElement> withSibling(final Predicate<? super UiElement> siblingPredicate) { + return new Predicate<UiElement>() { + @Override + public boolean apply(UiElement element) { + UiElement parent = element.getParent(); + if (parent == null) { + return false; + } + for (UiElement sibling : parent.getChildren(UiElement.VISIBLE)) { + if (sibling != element && siblingPredicate.apply(sibling)) { + return true; + } + } + return false; + } + + @Override + public String toString() { + return "withSibling(" + siblingPredicate + ")"; + } + }; + } + + public static Predicate<UiElement> withChild(final Predicate<? super UiElement> childPredicate) { + return new Predicate<UiElement>() { + @Override + public boolean apply(UiElement element) { + for (UiElement child : element.getChildren(UiElement.VISIBLE)) { + if (childPredicate.apply(child)) { + return true; + } + } + return false; + } + + @Override + public String toString() { + return "withChild(" + childPredicate + ")"; + } + }; + } +} |