1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package libcore.java.util.function;
18
19import junit.framework.TestCase;
20
21import java.util.concurrent.atomic.AtomicBoolean;
22import java.util.function.Predicate;
23
24public class PredicateTest extends TestCase {
25
26  public void testAnd() throws Exception {
27    Object arg = new Object();
28
29    AtomicBoolean alwaysTrueInvoked = new AtomicBoolean(false);
30    AtomicBoolean alwaysTrue2Invoked = new AtomicBoolean(false);
31    AtomicBoolean alwaysFalseInvoked = new AtomicBoolean(false);
32    AtomicBoolean alwaysFalse2Invoked = new AtomicBoolean(false);
33    AtomicBoolean[] invocationState = {
34        alwaysTrueInvoked, alwaysTrue2Invoked, alwaysFalseInvoked, alwaysFalse2Invoked };
35
36    Predicate<Object> alwaysTrue =
37        x -> { alwaysTrueInvoked.set(true); assertSame(x, arg); return true; };
38    Predicate<Object> alwaysTrue2 =
39        x -> { alwaysTrue2Invoked.set(true); assertSame(x, arg); return true; };
40    Predicate<Object> alwaysFalse =
41        x -> { alwaysFalseInvoked.set(true); assertSame(x, arg); return false; };
42    Predicate<Object> alwaysFalse2 =
43        x -> { alwaysFalse2Invoked.set(true); assertSame(x, arg); return false; };
44
45    // true && true
46    resetToFalse(invocationState);
47    assertTrue(alwaysTrue.and(alwaysTrue2).test(arg));
48    assertTrue(alwaysTrueInvoked.get() && alwaysTrue2Invoked.get());
49
50    // true && false
51    resetToFalse(invocationState);
52    assertFalse(alwaysTrue.and(alwaysFalse).test(arg));
53    assertTrue(alwaysTrueInvoked.get() && alwaysFalseInvoked.get());
54
55    // false && false
56    resetToFalse(invocationState);
57    assertFalse(alwaysFalse.and(alwaysFalse2).test(arg));
58    assertTrue(alwaysFalseInvoked.get() && !alwaysFalse2Invoked.get());
59
60    // false && true
61    resetToFalse(invocationState);
62    assertFalse(alwaysFalse.and(alwaysTrue).test(arg));
63    assertTrue(alwaysFalseInvoked.get() && !alwaysTrueInvoked.get());
64  }
65
66  public void testAnd_null() throws Exception {
67    Object arg = new Object();
68    Predicate<Object> alwaysTrue = x -> { assertSame(arg, x); return true; };
69    try {
70      alwaysTrue.and(null);
71      fail();
72    } catch (NullPointerException expected) {}
73  }
74
75  public void testNegate() throws Exception {
76    Predicate<Object> alwaysTrue = x -> true;
77    assertFalse(alwaysTrue.negate().test(null));
78
79    Predicate<Object> alwaysFalse = x -> false;
80    assertTrue(alwaysFalse.negate().test(null));
81  }
82
83  public void testOr() throws Exception {
84    Object arg = new Object();
85
86    AtomicBoolean alwaysTrueInvoked = new AtomicBoolean(false);
87    AtomicBoolean alwaysTrue2Invoked = new AtomicBoolean(false);
88    AtomicBoolean alwaysFalseInvoked = new AtomicBoolean(false);
89    AtomicBoolean alwaysFalse2Invoked = new AtomicBoolean(false);
90    AtomicBoolean[] invocationState = {
91        alwaysTrueInvoked, alwaysTrue2Invoked, alwaysFalseInvoked, alwaysFalse2Invoked };
92
93    Predicate<Object> alwaysTrue =
94        x -> { alwaysTrueInvoked.set(true); assertSame(x, arg); return true; };
95    Predicate<Object> alwaysTrue2 =
96        x -> { alwaysTrue2Invoked.set(true); assertSame(x, arg); return true; };
97    Predicate<Object> alwaysFalse =
98        x -> { alwaysFalseInvoked.set(true); assertSame(x, arg); return false; };
99    Predicate<Object> alwaysFalse2 =
100        x -> { alwaysFalse2Invoked.set(true); assertSame(x, arg); return false; };
101
102    // true || true
103    resetToFalse(invocationState);
104    assertTrue(alwaysTrue.or(alwaysTrue2).test(arg));
105    assertTrue(alwaysTrueInvoked.get() && !alwaysTrue2Invoked.get());
106
107    // true || false
108    resetToFalse(invocationState);
109    assertTrue(alwaysTrue.or(alwaysFalse).test(arg));
110    assertTrue(alwaysTrueInvoked.get() && !alwaysFalseInvoked.get());
111
112    // false || false
113    resetToFalse(invocationState);
114    assertFalse(alwaysFalse.or(alwaysFalse2).test(arg));
115    assertTrue(alwaysFalseInvoked.get() && alwaysFalse2Invoked.get());
116
117    // false || true
118    resetToFalse(invocationState);
119    assertTrue(alwaysFalse.or(alwaysTrue).test(arg));
120    assertTrue(alwaysFalseInvoked.get() && alwaysTrueInvoked.get());
121  }
122
123  public void testOr_null() throws Exception {
124    Predicate<Object> alwaysTrue = x -> true;
125    try {
126      alwaysTrue.or(null);
127      fail();
128    } catch (NullPointerException expected) {}
129  }
130
131  private static void resetToFalse(AtomicBoolean... toResets) {
132    for (AtomicBoolean toReset : toResets) {
133      toReset.set(false);
134    }
135  }
136}
137