1 /*
   2  * Copyright (c) 2012, 2013, 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 com.sun.javafx.binding;
  27 
  28 import java.util.Arrays;
  29 import java.util.Collections;
  30 import javafx.beans.InvalidationListener;
  31 import javafx.beans.Observable;
  32 import javafx.beans.property.SimpleListProperty;
  33 import javafx.beans.property.SimpleMapProperty;
  34 import javafx.beans.property.SimpleSetProperty;
  35 import javafx.beans.property.SimpleStringProperty;
  36 import javafx.beans.value.ChangeListener;
  37 import javafx.beans.value.ObservableListValue;
  38 import javafx.beans.value.ObservableMapValue;
  39 import javafx.beans.value.ObservableSetValue;
  40 import javafx.beans.value.ObservableValue;
  41 import javafx.collections.ListChangeListener;
  42 import javafx.collections.MapChangeListener;
  43 import javafx.collections.SetChangeListener;
  44 import org.junit.Test;
  45 
  46 import static org.junit.Assert.*;
  47 import org.junit.Before;
  48 
  49 public class ExpressionHelperUtilityTest {
  50     
  51     private ObservableValue observableValue;
  52     private ObservableListValue observableList;
  53     private ObservableMapValue observableMap;
  54     private ObservableSetValue observableSet;
  55     
  56     private InvalidationListener invalidationListener1;
  57     private InvalidationListener invalidationListener2;
  58     private ChangeListener changeListener1;
  59     private ChangeListener changeListener2;
  60     private ListChangeListener listChangeListener1;
  61     private ListChangeListener listChangeListener2;
  62     private MapChangeListener mapChangeListener1;
  63     private MapChangeListener mapChangeListener2;
  64     private SetChangeListener setChangeListener1;
  65     private SetChangeListener setChangeListener2;
  66     
  67     @Before
  68     public void setUp() {
  69         observableValue = new SimpleStringProperty();
  70         observableList = new SimpleListProperty();
  71         observableMap = new SimpleMapProperty();
  72         observableSet = new SimpleSetProperty();
  73         
  74         invalidationListener1 = new EmptyInvalidationListener();
  75         invalidationListener2 = new EmptyInvalidationListener();
  76         changeListener1 = new EmptyChangeListener();
  77         changeListener2 = new EmptyChangeListener();
  78         listChangeListener1 = new EmptyListChangeListener();
  79         listChangeListener2 = new EmptyListChangeListener();
  80         mapChangeListener1 = new EmptyMapChangeListener();
  81         mapChangeListener2 = new EmptyMapChangeListener();
  82         setChangeListener1 = new EmptySetChangeListener();
  83         setChangeListener2 = new EmptySetChangeListener();
  84     }
  85     
  86     @Test
  87     public void testGetInvalidationListenerFromValue() {
  88         // empty helper
  89         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableValue));
  90         
  91         // SingleInvalidation
  92         observableValue.addListener(invalidationListener1);
  93         assertEquals(Collections.singletonList(invalidationListener1), ExpressionHelperUtility.getInvalidationListeners(observableValue));
  94         observableValue.removeListener(invalidationListener1);
  95         
  96         // SingleChange
  97         observableValue.addListener(changeListener1);
  98         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableValue));
  99         observableValue.removeListener(changeListener1);
 100         
 101         // Generic
 102         observableValue.addListener(changeListener1);
 103         observableValue.addListener(changeListener2);
 104         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableValue));
 105         observableValue.addListener(invalidationListener1);
 106         assertEquals(Collections.singletonList(invalidationListener1), ExpressionHelperUtility.getInvalidationListeners(observableValue));
 107         observableValue.addListener(invalidationListener2);
 108         assertTrue(Arrays.asList(invalidationListener1, invalidationListener2).equals(ExpressionHelperUtility.getInvalidationListeners(observableValue))
 109                 || Arrays.asList(invalidationListener2, invalidationListener1).equals(ExpressionHelperUtility.getInvalidationListeners(observableValue)));
 110     }
 111     
 112     @Test
 113     public void testGetChangeListenerFromValue() {
 114         // empty helper
 115         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableValue));
 116         
 117         // SingleInvalidation
 118         observableValue.addListener(invalidationListener1);
 119         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableValue));
 120         observableValue.removeListener(invalidationListener1);
 121         
 122         // SingleChange
 123         observableValue.addListener(changeListener1);
 124         assertEquals(Collections.singletonList(changeListener1), ExpressionHelperUtility.getChangeListeners(observableValue));
 125         observableValue.removeListener(changeListener1);
 126         
 127         // Generic
 128         observableValue.addListener(invalidationListener1);
 129         observableValue.addListener(invalidationListener2);
 130         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableValue));
 131         observableValue.addListener(changeListener1);
 132         assertEquals(Collections.singletonList(changeListener1), ExpressionHelperUtility.getChangeListeners(observableValue));
 133         observableValue.addListener(changeListener2);
 134         assertTrue(Arrays.asList(changeListener1, changeListener2).equals(ExpressionHelperUtility.getChangeListeners(observableValue))
 135                 || Arrays.asList(changeListener2, changeListener1).equals(ExpressionHelperUtility.getChangeListeners(observableValue)));
 136     }
 137 
 138     @Test
 139     public void testGetInvalidationListenerFromList() {
 140         // empty helper
 141         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableList));
 142 
 143         // SingleInvalidation
 144         observableList.addListener(invalidationListener1);
 145         assertEquals(Collections.singletonList(invalidationListener1), ExpressionHelperUtility.getInvalidationListeners(observableList));
 146         observableList.removeListener(invalidationListener1);
 147 
 148         // SingleChange
 149         observableList.addListener(changeListener1);
 150         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableList));
 151         observableList.removeListener(changeListener1);
 152 
 153         // SingeListChange
 154         observableList.addListener(listChangeListener1);
 155         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableList));
 156         observableList.removeListener(listChangeListener1);
 157 
 158         // Generic
 159         observableList.addListener(changeListener1);
 160         observableList.addListener(listChangeListener1);
 161         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableList));
 162         observableList.addListener(invalidationListener1);
 163         assertEquals(Collections.singletonList(invalidationListener1), ExpressionHelperUtility.getInvalidationListeners(observableList));
 164         observableList.addListener(invalidationListener2);
 165         assertTrue(Arrays.asList(invalidationListener1, invalidationListener2).equals(ExpressionHelperUtility.getInvalidationListeners(observableList))
 166                            || Arrays.asList(invalidationListener2, invalidationListener1).equals(ExpressionHelperUtility.getInvalidationListeners(observableList)));
 167     }
 168 
 169     @Test
 170     public void testGetChangeListenerFromList() {
 171         // empty helper
 172         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableList));
 173 
 174         // SingleInvalidation
 175         observableList.addListener(invalidationListener1);
 176         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableList));
 177         observableList.removeListener(invalidationListener1);
 178 
 179         // SingleChange
 180         observableList.addListener(changeListener1);
 181         assertEquals(Collections.singletonList(changeListener1), ExpressionHelperUtility.getChangeListeners(observableList));
 182         observableList.removeListener(changeListener1);
 183 
 184         // SingeListChange
 185         observableList.addListener(listChangeListener1);
 186         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableList));
 187         observableList.removeListener(listChangeListener1);
 188 
 189         // Generic
 190         observableList.addListener(invalidationListener1);
 191         observableList.addListener(listChangeListener1);
 192         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableList));
 193         observableList.addListener(changeListener1);
 194         assertEquals(Collections.singletonList(changeListener1), ExpressionHelperUtility.getChangeListeners(observableList));
 195         observableList.addListener(changeListener2);
 196         assertTrue(Arrays.asList(changeListener1, changeListener2).equals(ExpressionHelperUtility.getChangeListeners(observableList))
 197                            || Arrays.asList(changeListener2, changeListener1).equals(ExpressionHelperUtility.getChangeListeners(observableList)));
 198     }
 199 
 200     @Test
 201     public void testGetListChangeListenerFromList() {
 202         // empty helper
 203         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getListChangeListeners(observableList));
 204 
 205         // SingleInvalidation
 206         observableList.addListener(invalidationListener1);
 207         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getListChangeListeners(observableList));
 208         observableList.removeListener(invalidationListener1);
 209 
 210         // SingleChange
 211         observableList.addListener(changeListener1);
 212         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getListChangeListeners(observableList));
 213         observableList.removeListener(changeListener1);
 214 
 215         // SingeListChange
 216         observableList.addListener(listChangeListener1);
 217         assertEquals(Collections.singletonList(listChangeListener1), ExpressionHelperUtility.getListChangeListeners(observableList));
 218         observableList.removeListener(listChangeListener1);
 219 
 220         // Generic
 221         observableList.addListener(invalidationListener1);
 222         observableList.addListener(changeListener1);
 223         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getListChangeListeners(observableList));
 224         observableList.addListener(listChangeListener1);
 225         assertEquals(Collections.singletonList(listChangeListener1), ExpressionHelperUtility.getListChangeListeners(observableList));
 226         observableList.addListener(listChangeListener2);
 227         assertTrue(Arrays.asList(listChangeListener1, listChangeListener2).equals(ExpressionHelperUtility.getListChangeListeners(observableList))
 228                            || Arrays.asList(listChangeListener2, listChangeListener1).equals(ExpressionHelperUtility.getListChangeListeners(observableList)));
 229     }
 230 
 231     @Test
 232     public void testGetInvalidationListenerFromMap() {
 233         // empty helper
 234         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableMap));
 235 
 236         // SingleInvalidation
 237         observableMap.addListener(invalidationListener1);
 238         assertEquals(Collections.singletonList(invalidationListener1), ExpressionHelperUtility.getInvalidationListeners(observableMap));
 239         observableMap.removeListener(invalidationListener1);
 240 
 241         // SingleChange
 242         observableMap.addListener(changeListener1);
 243         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableMap));
 244         observableMap.removeListener(changeListener1);
 245 
 246         // SingeMapChange
 247         observableMap.addListener(mapChangeListener1);
 248         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableMap));
 249         observableMap.removeListener(mapChangeListener1);
 250 
 251         // Generic
 252         observableMap.addListener(changeListener1);
 253         observableMap.addListener(mapChangeListener1);
 254         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableMap));
 255         observableMap.addListener(invalidationListener1);
 256         assertEquals(Collections.singletonList(invalidationListener1), ExpressionHelperUtility.getInvalidationListeners(observableMap));
 257         observableMap.addListener(invalidationListener2);
 258         assertTrue(Arrays.asList(invalidationListener1, invalidationListener2).equals(ExpressionHelperUtility.getInvalidationListeners(observableMap))
 259                            || Arrays.asList(invalidationListener2, invalidationListener1).equals(ExpressionHelperUtility.getInvalidationListeners(observableMap)));
 260     }
 261 
 262     @Test
 263     public void testGetChangeListenerFromMap() {
 264         // empty helper
 265         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableMap));
 266 
 267         // SingleInvalidation
 268         observableMap.addListener(invalidationListener1);
 269         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableMap));
 270         observableMap.removeListener(invalidationListener1);
 271 
 272         // SingleChange
 273         observableMap.addListener(changeListener1);
 274         assertEquals(Collections.singletonList(changeListener1), ExpressionHelperUtility.getChangeListeners(observableMap));
 275         observableMap.removeListener(changeListener1);
 276 
 277         // SingeMapChange
 278         observableMap.addListener(mapChangeListener1);
 279         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableMap));
 280         observableMap.removeListener(mapChangeListener1);
 281 
 282         // Generic
 283         observableMap.addListener(invalidationListener1);
 284         observableMap.addListener(mapChangeListener1);
 285         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableMap));
 286         observableMap.addListener(changeListener1);
 287         assertEquals(Collections.singletonList(changeListener1), ExpressionHelperUtility.getChangeListeners(observableMap));
 288         observableMap.addListener(changeListener2);
 289         assertTrue(Arrays.asList(changeListener1, changeListener2).equals(ExpressionHelperUtility.getChangeListeners(observableMap))
 290                            || Arrays.asList(changeListener2, changeListener1).equals(ExpressionHelperUtility.getChangeListeners(observableMap)));
 291     }
 292 
 293     @Test
 294     public void testGetMapChangeListenerFromMap() {
 295         // empty helper
 296         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getMapChangeListeners(observableMap));
 297 
 298         // SingleInvalidation
 299         observableMap.addListener(invalidationListener1);
 300         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getMapChangeListeners(observableMap));
 301         observableMap.removeListener(invalidationListener1);
 302 
 303         // SingleChange
 304         observableMap.addListener(changeListener1);
 305         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getMapChangeListeners(observableMap));
 306         observableMap.removeListener(changeListener1);
 307 
 308         // SingeMapChange
 309         observableMap.addListener(mapChangeListener1);
 310         assertEquals(Collections.singletonList(mapChangeListener1), ExpressionHelperUtility.getMapChangeListeners(observableMap));
 311         observableMap.removeListener(mapChangeListener1);
 312 
 313         // Generic
 314         observableMap.addListener(invalidationListener1);
 315         observableMap.addListener(changeListener1);
 316         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getMapChangeListeners(observableMap));
 317         observableMap.addListener(mapChangeListener1);
 318         assertEquals(Collections.singletonList(mapChangeListener1), ExpressionHelperUtility.getMapChangeListeners(observableMap));
 319         observableMap.addListener(mapChangeListener2);
 320         assertTrue(Arrays.asList(mapChangeListener1, mapChangeListener2).equals(ExpressionHelperUtility.getMapChangeListeners(observableMap))
 321                            || Arrays.asList(mapChangeListener2, mapChangeListener1).equals(ExpressionHelperUtility.getMapChangeListeners(observableMap)));
 322     }
 323 
 324     @Test
 325     public void testGetInvalidationListenerFromSet() {
 326         // empty helper
 327         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableSet));
 328 
 329         // SingleInvalidation
 330         observableSet.addListener(invalidationListener1);
 331         assertEquals(Collections.singletonList(invalidationListener1), ExpressionHelperUtility.getInvalidationListeners(observableSet));
 332         observableSet.removeListener(invalidationListener1);
 333 
 334         // SingleChange
 335         observableSet.addListener(changeListener1);
 336         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableSet));
 337         observableSet.removeListener(changeListener1);
 338 
 339         // SingeSetChange
 340         observableSet.addListener(setChangeListener1);
 341         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableSet));
 342         observableSet.removeListener(setChangeListener1);
 343 
 344         // Generic
 345         observableSet.addListener(changeListener1);
 346         observableSet.addListener(setChangeListener1);
 347         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getInvalidationListeners(observableSet));
 348         observableSet.addListener(invalidationListener1);
 349         assertEquals(Collections.singletonList(invalidationListener1), ExpressionHelperUtility.getInvalidationListeners(observableSet));
 350         observableSet.addListener(invalidationListener2);
 351         assertTrue(Arrays.asList(invalidationListener1, invalidationListener2).equals(ExpressionHelperUtility.getInvalidationListeners(observableSet))
 352                            || Arrays.asList(invalidationListener2, invalidationListener1).equals(ExpressionHelperUtility.getInvalidationListeners(observableSet)));
 353     }
 354 
 355     @Test
 356     public void testGetChangeListenerFromSet() {
 357         // empty helper
 358         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableSet));
 359 
 360         // SingleInvalidation
 361         observableSet.addListener(invalidationListener1);
 362         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableSet));
 363         observableSet.removeListener(invalidationListener1);
 364 
 365         // SingleChange
 366         observableSet.addListener(changeListener1);
 367         assertEquals(Collections.singletonList(changeListener1), ExpressionHelperUtility.getChangeListeners(observableSet));
 368         observableSet.removeListener(changeListener1);
 369 
 370         // SingeSetChange
 371         observableSet.addListener(setChangeListener1);
 372         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableSet));
 373         observableSet.removeListener(setChangeListener1);
 374 
 375         // Generic
 376         observableSet.addListener(invalidationListener1);
 377         observableSet.addListener(setChangeListener1);
 378         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getChangeListeners(observableSet));
 379         observableSet.addListener(changeListener1);
 380         assertEquals(Collections.singletonList(changeListener1), ExpressionHelperUtility.getChangeListeners(observableSet));
 381         observableSet.addListener(changeListener2);
 382         assertTrue(Arrays.asList(changeListener1, changeListener2).equals(ExpressionHelperUtility.getChangeListeners(observableSet))
 383                            || Arrays.asList(changeListener2, changeListener1).equals(ExpressionHelperUtility.getChangeListeners(observableSet)));
 384     }
 385 
 386     @Test
 387     public void testGetSetChangeListenerFromSet() {
 388         // empty helper
 389         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getSetChangeListeners(observableSet));
 390 
 391         // SingleInvalidation
 392         observableSet.addListener(invalidationListener1);
 393         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getSetChangeListeners(observableSet));
 394         observableSet.removeListener(invalidationListener1);
 395 
 396         // SingleChange
 397         observableSet.addListener(changeListener1);
 398         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getSetChangeListeners(observableSet));
 399         observableSet.removeListener(changeListener1);
 400 
 401         // SingeSetChange
 402         observableSet.addListener(setChangeListener1);
 403         assertEquals(Collections.singletonList(setChangeListener1), ExpressionHelperUtility.getSetChangeListeners(observableSet));
 404         observableSet.removeListener(setChangeListener1);
 405 
 406         // Generic
 407         observableSet.addListener(invalidationListener1);
 408         observableSet.addListener(changeListener1);
 409         assertEquals(Collections.emptyList(), ExpressionHelperUtility.getSetChangeListeners(observableSet));
 410         observableSet.addListener(setChangeListener1);
 411         assertEquals(Collections.singletonList(setChangeListener1), ExpressionHelperUtility.getSetChangeListeners(observableSet));
 412         observableSet.addListener(setChangeListener2);
 413         assertTrue(Arrays.asList(setChangeListener1, setChangeListener2).equals(ExpressionHelperUtility.getSetChangeListeners(observableSet))
 414                            || Arrays.asList(setChangeListener2, setChangeListener1).equals(ExpressionHelperUtility.getSetChangeListeners(observableSet)));
 415     }
 416 
 417     private static class EmptyInvalidationListener implements InvalidationListener {
 418         @Override public void invalidated(Observable observable) { }
 419     }
 420     
 421     private static class EmptyChangeListener implements ChangeListener<Object> {
 422         @Override public void changed(ObservableValue<? extends Object> observableValue, Object oldValue, Object newValue) { }
 423     }
 424     
 425     private static class EmptyListChangeListener implements ListChangeListener<Object> {
 426         @Override public void onChanged(Change<? extends Object> change) { }
 427     }
 428     
 429     private static class EmptyMapChangeListener implements MapChangeListener<Object, Object> {
 430         @Override public void onChanged(Change<? extends Object, ? extends Object> change) { }
 431     }
 432     
 433     private static class EmptySetChangeListener implements SetChangeListener<Object> {
 434         @Override public void onChanged(Change<? extends Object> change) { }
 435     }
 436     
 437 }