1 /* 2 * Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package test.javafx.collections; 27 28 import test.javafx.collections.Person; 29 import test.javafx.collections.MockListObserver; 30 import com.sun.javafx.collections.ObservableListWrapper; 31 import java.util.Arrays; 32 import java.util.Collections; 33 import java.util.List; 34 import java.util.function.Predicate; 35 import javafx.beans.property.ObjectProperty; 36 import javafx.beans.property.SimpleObjectProperty; 37 import javafx.collections.FXCollections; 38 import javafx.collections.ObservableList; 39 import javafx.collections.ObservableListWrapperShim; 40 import javafx.collections.transformation.FilteredList; 41 import static org.junit.Assert.*; 42 import org.junit.Before; 43 import org.junit.Test; 44 45 public class FilteredListTest { 46 47 private ObservableList<String> list; 48 private MockListObserver<String> mlo; 49 private FilteredList<String> filteredList; 50 51 @Before 52 public void setUp() { 53 list = FXCollections.observableArrayList(); 54 list.addAll("a", "c", "d", "c"); 55 Predicate<String> predicate = (String e) -> !e.equals("c"); 56 mlo = new MockListObserver<String>(); 57 filteredList = new FilteredList<>(list, predicate); 58 filteredList.addListener(mlo); 59 } 60 61 62 @Test 63 public void testLiveMode() { 64 assertEquals(Arrays.asList("a", "d"), filteredList); 65 mlo.check0(); 66 } 67 68 @Test 69 public void testLiveMode_Add() { 70 list.clear(); 71 mlo.clear(); 72 assertEquals(Collections.emptyList(), filteredList); 73 list.addAll("a", "c", "d", "c"); 74 assertEquals(Arrays.asList("a", "d"), filteredList); 75 mlo.check1AddRemove(filteredList, Collections.<String>emptyList(), 0, 2); 76 mlo.clear(); 77 list.add("c"); 78 mlo.check0(); 79 list.add(1, "b"); 80 assertEquals(Arrays.asList("a", "b", "d"), filteredList); 81 mlo.check1AddRemove(filteredList, Collections.<String>emptyList(), 1, 2); 82 } 83 84 @Test 85 public void testLiveMode_Remove() { 86 list.removeAll(Arrays.asList("c")); 87 assertEquals(Arrays.asList("a", "d"), filteredList); 88 mlo.check0(); 89 mlo.clear(); 90 list.remove("a"); 91 assertEquals(Arrays.asList("d"), filteredList); 92 mlo.check1AddRemove(filteredList, Arrays.asList("a"), 0, 0); 93 } 94 95 @Test 96 public void testLiveMode_Permutation() { 97 FXCollections.sort(list, (o1, o2) -> -o1.compareTo(o2)); 98 mlo.check1Permutation(filteredList, new int[] {1, 0}); 99 assertEquals(Arrays.asList("d", "a"), filteredList); 100 } 101 102 @Test 103 public void testLiveMode_changeMatcher() { 104 ObjectProperty<Predicate<String>> pProperty = new SimpleObjectProperty<>(); 105 pProperty.set((String e) -> !e.equals("c")); 106 filteredList = new FilteredList<>(list); 107 filteredList.predicateProperty().bind(pProperty); 108 filteredList.addListener(mlo); 109 assertEquals(Arrays.asList("a", "d"), filteredList); 110 mlo.check0(); 111 pProperty.set((String s) -> !s.equals("d")); 112 mlo.check1AddRemove(filteredList, Arrays.asList("a", "d"), 0, 3); 113 } 114 115 @Test 116 public void testLiveMode_mutableElement() { 117 ObservableList<Person> list = Person.createPersonsList("A", "BB", "C"); 118 119 FilteredList<Person> filtered = new FilteredList<>(list, 120 (Person p) -> p.name.get().length() > 1); 121 MockListObserver<Person> lo = new MockListObserver<>(); 122 filtered.addListener(lo); 123 124 assertEquals(Arrays.asList(new Person("BB")), filtered); 125 126 list.get(0).name.set("AA"); 127 lo.check1AddRemove(filtered, Collections.EMPTY_LIST, 0, 1); 128 assertEquals(Person.createPersonsList("AA", "BB"), filtered); 129 130 lo.clear(); 131 list.get(1).name.set("BBB"); 132 lo.check1Update(filtered, 1, 2); 133 assertEquals(Person.createPersonsList("AA", "BBB"), filtered); 134 135 lo.clear(); 136 list.get(1).name.set("B"); 137 lo.check1AddRemove(filtered, Person.createPersonsList("B"), 1, 1); 138 assertEquals(Person.createPersonsList("AA"), filtered); 139 } 140 141 @Test 142 public void testLiveMode_mutableElementEmptyList() { 143 ObservableList<Person> list = Person.createPersonsList("A", "B", "C"); 144 145 FilteredList<Person> filtered = new FilteredList<>(list, 146 (Person p) -> p.name.get().length() > 1); 147 MockListObserver<Person> lo = new MockListObserver<>(); 148 filtered.addListener(lo); 149 150 assertEquals(Collections.EMPTY_LIST, filtered); 151 152 list.get(0).name.set("AA"); 153 lo.check1AddRemove(filtered, Collections.EMPTY_LIST, 0, 1); 154 assertEquals(Person.createPersonsList("AA"), filtered); 155 } 156 157 @Test 158 public void testLiveMode_mutableElements() { 159 Person p1 = new Person("A"); 160 ObservableList<Person> list = Person.createPersonsList( 161 p1, p1, new Person("BB"), new Person("B"), p1, p1, new Person("BC"), p1, new Person("C")); 162 163 FilteredList<Person> filtered = new FilteredList<>(list, 164 (Person p) -> p.name.get().length() > 1); 165 MockListObserver<Person> lo = new MockListObserver<>(); 166 filtered.addListener(lo); 167 168 assertEquals(Person.createPersonsList("BB", "BC"), filtered); 169 170 p1.name.set("AA"); 171 lo.checkAddRemove(0, filtered, Collections.EMPTY_LIST, 0, 2); 172 lo.checkAddRemove(1, filtered, Collections.EMPTY_LIST, 3, 5); 173 lo.checkAddRemove(2, filtered, Collections.EMPTY_LIST, 6, 7); 174 assertEquals(Person.createPersonsList("AA", "AA", "BB", "AA", "AA", "BC", "AA"), filtered); 175 176 lo.clear(); 177 p1.name.set("AAA"); 178 lo.checkUpdate(0, filtered, 0, 2); 179 lo.checkUpdate(1, filtered, 3, 5); 180 lo.checkUpdate(2, filtered, 6, 7); 181 assertEquals(Person.createPersonsList("AAA", "AAA", "BB", "AAA", "AAA", "BC", "AAA"), filtered); 182 183 lo.clear(); 184 p1.name.set("A"); 185 lo.checkAddRemove(0, filtered, Person.createPersonsList("A", "A"), 0, 0); 186 lo.checkAddRemove(1, filtered, Person.createPersonsList("A", "A"), 1, 1); 187 lo.checkAddRemove(2, filtered, Person.createPersonsList("A"), 2, 2); 188 assertEquals(Person.createPersonsList( "BB", "BC"), filtered); 189 } 190 191 private static class Updater<E> extends ObservableListWrapper<E> { 192 public Updater(List<E> list) { 193 super(list); 194 } 195 196 public void update(int from, int to) { 197 ObservableListWrapperShim.beginChange(this); 198 for (int i = from; i < to; ++i) { 199 ObservableListWrapperShim.nextUpdate(this, i); 200 } 201 ObservableListWrapperShim.endChange(this); 202 } 203 204 public void updateAll() { 205 update(0, size()); 206 } 207 } 208 209 @Test 210 public void testCustomMutableElements() { 211 Updater<Person> list = new Updater<>(Person.createPersonsFromNames( 212 "A0", "A1", "BB2", "B3", "A4", "A5", "BC6", "A7", "C8")); 213 214 FilteredList<Person> filtered = new FilteredList<>(list, 215 (Person p) -> p.name.get().length() > 2); 216 MockListObserver<Person> lo = new MockListObserver<>(); 217 filtered.addListener(lo); 218 219 assertEquals(Person.createPersonsList("BB2", "BC6"), filtered); 220 221 list.updateAll(); 222 lo.checkUpdate(0, filtered, 0, filtered.size()); 223 224 lo.clear(); 225 list.get(0).name.set("AA0"); 226 list.get(3).name.set("BB3"); 227 list.get(5).name.set("AA5"); 228 list.get(6).name.set("B6"); 229 list.get(7).name.set("AA7"); 230 list.updateAll(); 231 assertEquals(Person.createPersonsList("AA0", "BB2", "BB3", "AA5", "AA7"), filtered); 232 lo.checkAddRemove(0, filtered, Collections.EMPTY_LIST, 0, 1); 233 lo.checkAddRemove(1, filtered, Person.createPersonsList("B6"), 2, 5); 234 lo.checkUpdate(2, filtered, 1, 2); 235 } 236 237 @Test 238 public void testNullPredicate() { 239 filteredList.setPredicate(null); 240 assertEquals(list.size(), filteredList.size()); 241 assertEquals(list, filteredList); 242 mlo.check1AddRemove(filteredList, Arrays.asList("a", "d"), 0, 4); 243 } 244 245 @Test 246 public void testSingleArgConstructor() { 247 filteredList = new FilteredList<>(list); 248 assertEquals(list.size(), filteredList.size()); 249 assertEquals(list, filteredList); 250 } 251 }