Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 50826c5f authored by Paul Duffin's avatar Paul Duffin Committed by Android (Google) Code Review
Browse files

Merge "Clean up Predicate related code in android.test" into oc-dev-plus-aosp

parents 834cf8d6 fedb4b74
Loading
Loading
Loading
Loading
+0 −1
Original line number Diff line number Diff line
@@ -18,7 +18,6 @@ LOCAL_STATIC_JAVA_LIBRARIES := \
    android-support-test \
    frameworks-base-testutils \
    mockito-target-minus-junit4 \
    legacy-android-tests

LOCAL_JAVA_LIBRARIES := android.test.runner

+0 −13
Original line number Diff line number Diff line
@@ -48,19 +48,6 @@ LOCAL_JAVA_LIBRARIES := core-oj core-libart framework junit

include $(BUILD_STATIC_JAVA_LIBRARY)

# Build the legacy-android-tests library
# ======================================
include $(CLEAR_VARS)

LOCAL_SRC_FILES := \
    $(call all-java-files-under, tests)
LOCAL_MODULE := legacy-android-tests
LOCAL_NO_STANDARD_LIBRARIES := true
LOCAL_JAVA_LIBRARIES := core-oj core-libart framework junit
LOCAL_STATIC_JAVA_LIBRARIES := legacy-android-test

include $(BUILD_STATIC_JAVA_LIBRARY)

ifeq ($(HOST_OS),linux)
# Build the legacy-performance-test-hostdex library
# =================================================
+0 −127
Original line number Diff line number Diff line
/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * 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 com.android.internal.util;

import java.util.Arrays;

/**
 * Predicates contains static methods for creating the standard set of
 * {@code Predicate} objects.
 *
 * @hide
 */
public class Predicates {

    private Predicates() {
    }

    /**
     * Returns a Predicate that evaluates to true iff each of its components
     * evaluates to true.  The components are evaluated in order, and evaluation
     * will be "short-circuited" as soon as the answer is determined.
     */
    public static <T> Predicate<T> and(Predicate<? super T>... components) {
        return Predicates.<T>and(Arrays.asList(components));
    }

    /**
     * Returns a Predicate that evaluates to true iff each of its components
     * evaluates to true.  The components are evaluated in order, and evaluation
     * will be "short-circuited" as soon as the answer is determined.  Does not
     * defensively copy the iterable passed in, so future changes to it will alter
     * the behavior of this Predicate. If components is empty, the returned
     * Predicate will always evaluate to true.
     */
    public static <T> Predicate<T> and(Iterable<? extends Predicate<? super T>> components) {
        return new AndPredicate(components);
    }

    /**
     * Returns a Predicate that evaluates to true iff any one of its components
     * evaluates to true.  The components are evaluated in order, and evaluation
     * will be "short-circuited" as soon as the answer is determined.
     */
    public static <T> Predicate<T> or(Predicate<? super T>... components) {
        return Predicates.<T>or(Arrays.asList(components));
    }

    /**
     * Returns a Predicate that evaluates to true iff any one of its components
     * evaluates to true.  The components are evaluated in order, and evaluation
     * will be "short-circuited" as soon as the answer is determined.  Does not
     * defensively copy the iterable passed in, so future changes to it will alter
     * the behavior of this Predicate. If components is empty, the returned
     * Predicate will always evaluate to false.
     */
    public static <T> Predicate<T> or(Iterable<? extends Predicate<? super T>> components) {
        return new OrPredicate(components);
    }

    /**
     * Returns a Predicate that evaluates to true iff the given Predicate
     * evaluates to false.
     */
    public static <T> Predicate<T> not(Predicate<? super T> predicate) {
        return new NotPredicate<T>(predicate);
    }

    private static class AndPredicate<T> implements Predicate<T> {
        private final Iterable<? extends Predicate<? super T>> components;

        private AndPredicate(Iterable<? extends Predicate<? super T>> components) {
            this.components = components;
        }

        public boolean apply(T t) {
            for (Predicate<? super T> predicate : components) {
                if (!predicate.apply(t)) {
                    return false;
                }
            }
            return true;
        }
    }

    private static class OrPredicate<T> implements Predicate<T> {
        private final Iterable<? extends Predicate<? super T>> components;

        private OrPredicate(Iterable<? extends Predicate<? super T>> components) {
            this.components = components;
        }

        public boolean apply(T t) {
            for (Predicate<? super T> predicate : components) {
                if (predicate.apply(t)) {
                    return true;
                }
            }
            return false;
        }
    }

    private static class NotPredicate<T> implements Predicate<T> {
        private final Predicate<? super T> predicate;

        private NotPredicate(Predicate<? super T> predicate) {
            this.predicate = predicate;
        }

        public boolean apply(T t) {
            return !predicate.apply(t);
        }
    }
}
+0 −74
Original line number Diff line number Diff line
/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * 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 com.android.internal.util;

import junit.framework.TestCase;

import java.util.ArrayList;
import java.util.Collections;

public class PredicatesTest extends TestCase {

    private static final Predicate<Object> TRUE = new Predicate<Object>() {
        public boolean apply(Object o) {
            return true;
        }
    };

    private static final Predicate<Object> FALSE = new Predicate<Object>() {
        public boolean apply(Object o) {
            return false;
        }
    };

    public void testAndPredicate_AllConditionsTrue() throws Exception {
        assertTrue(Predicates.and(newArrayList(TRUE)).apply(null));
        assertTrue(Predicates.and(newArrayList(TRUE, TRUE)).apply(null));
    }

    public void testAndPredicate_AtLeastOneConditionIsFalse() throws Exception {
        assertFalse(Predicates.and(newArrayList(FALSE, TRUE, TRUE)).apply(null));
        assertFalse(Predicates.and(newArrayList(TRUE, FALSE, TRUE)).apply(null));
        assertFalse(Predicates.and(newArrayList(TRUE, TRUE, FALSE)).apply(null));
    }

    public void testOrPredicate_AllConditionsTrue() throws Exception {
        assertTrue(Predicates.or(newArrayList(TRUE, TRUE, TRUE)).apply(null));
    }

    public void testOrPredicate_AllConditionsFalse() throws Exception {
        assertFalse(Predicates.or(newArrayList(FALSE, FALSE, FALSE)).apply(null));
    }

    public void testOrPredicate_AtLeastOneConditionIsTrue() throws Exception {
        assertTrue(Predicates.or(newArrayList(TRUE, FALSE, FALSE)).apply(null));
        assertTrue(Predicates.or(newArrayList(FALSE, TRUE, FALSE)).apply(null));
        assertTrue(Predicates.or(newArrayList(FALSE, FALSE, TRUE)).apply(null));
    }

    public void testNotPredicate() throws Exception {
        assertTrue(Predicates.not(FALSE).apply(null));
        assertFalse(Predicates.not(TRUE).apply(null));
    }

    private static <E> ArrayList<E> newArrayList(E... elements) {
        ArrayList<E> list = new ArrayList<E>();
        Collections.addAll(list, elements);
        return list;
    }

}
Loading