1 /* 2 * Copyright (c) 2012, 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.binding; 27 28 import java.util.Arrays; 29 import java.util.Collection; 30 import java.util.concurrent.Callable; 31 import javafx.beans.Observable; 32 import javafx.beans.binding.Binding; 33 import javafx.beans.binding.Bindings; 34 import javafx.beans.property.Property; 35 import javafx.beans.property.SimpleBooleanProperty; 36 import javafx.beans.property.SimpleDoubleProperty; 37 import javafx.beans.property.SimpleFloatProperty; 38 import javafx.beans.property.SimpleIntegerProperty; 39 import javafx.beans.property.SimpleLongProperty; 40 import javafx.beans.property.SimpleObjectProperty; 41 import javafx.beans.property.SimpleStringProperty; 42 import test.com.sun.javafx.binding.ErrorLoggingUtiltity; 43 import org.junit.BeforeClass; 44 import org.junit.Test; 45 import org.junit.runner.RunWith; 46 import org.junit.runners.Parameterized; 47 48 import static org.junit.Assert.*; 49 50 /** 51 */ 52 @RunWith(Parameterized.class) 53 public class BindingsCreateBindingTest<T> { 54 55 private static final float EPSILON_FLOAT = 1e-5f; 56 private static final double EPSILON_DOUBLE = 1e-10; 57 58 private static interface Functions<S> { 59 public Binding<S> create(Callable<S> func, Observable... dependencies); 60 public void check(S value0, S value1); 61 } 62 63 private final Property<T> p0; 64 private final Property<T> p1; 65 private final Functions<T> f; 66 private final T value0; 67 private final T value1; 68 private final T defaultValue; 69 70 @BeforeClass 71 public static void setUpClass() { 72 ErrorLoggingUtiltity.reset(); 73 } 74 75 public BindingsCreateBindingTest(Property<T> p0, Property<T> p1, Functions<T> f, T value0, T value1, T defaultValue) { 76 this.p0 = p0; 77 this.p1 = p1; 78 this.f = f; 79 this.value0 = value0; 80 this.value1 = value1; 81 this.defaultValue = defaultValue; 82 } 83 84 @Test 85 public void testNoDependencies() { 86 // func returns value0, no dependencies specified 87 final Callable<T> func0 = () -> value0; 88 final Binding<T> binding0 = f.create(func0); 89 90 f.check(value0, binding0.getValue()); 91 assertTrue(binding0.getDependencies().isEmpty()); 92 binding0.dispose(); 93 94 // func returns value1, dependencies set to null 95 final Callable<T> func1 = () -> value1; 96 final Binding<T> binding1 = f.create(func1, (Observable[])null); 97 98 f.check(value1, binding1.getValue()); 99 assertTrue(binding1.getDependencies().isEmpty()); 100 binding1.dispose(); 101 102 // func throws exception, dependencies set to empty array 103 final Callable<T> func2 = () -> { 104 throw new Exception(); 105 }; 106 final Binding<T> binding2 = f.create(func2, new Observable [0]); 107 108 f.check(defaultValue, binding2.getValue()); 109 ErrorLoggingUtiltity.checkWarning(Exception.class); 110 assertTrue(binding2.getDependencies().isEmpty()); 111 binding2.dispose(); 112 } 113 114 @Test 115 public void testOneDependency() { 116 final Callable<T> func = () -> p0.getValue(); 117 final Binding<T> binding = f.create(func, p0); 118 119 f.check(p0.getValue(), binding.getValue()); 120 assertEquals(binding.getDependencies(), Arrays.asList(p0)); 121 p0.setValue(value1); 122 f.check(p0.getValue(), binding.getValue()); 123 binding.dispose(); 124 } 125 126 @Test 127 public void testCreateBoolean_TwoDependencies() { 128 final Callable<T> func = () -> p0.getValue(); 129 final Binding<T> binding = f.create(func, p0, p1); 130 131 f.check(p0.getValue(), binding.getValue()); 132 assertTrue(binding.getDependencies().equals(Arrays.asList(p0, p1)) || binding.getDependencies().equals((Arrays.asList(p1, p0)))); 133 p0.setValue(value1); 134 f.check(p0.getValue(), binding.getValue()); 135 binding.dispose(); 136 } 137 138 @Parameterized.Parameters 139 public static Collection<Object[]> parameters() { 140 return Arrays.asList(new Object[][] { 141 { 142 new SimpleBooleanProperty(), new SimpleBooleanProperty(), 143 new Functions<Boolean>() { 144 @Override 145 public Binding<Boolean> create(Callable<Boolean> func, Observable... dependencies) { 146 return Bindings.createBooleanBinding(func, dependencies); 147 } 148 149 @Override 150 public void check(Boolean value0, Boolean value1) { 151 assertEquals(value0, value1); 152 } 153 }, 154 true, false, false 155 }, 156 { 157 new SimpleDoubleProperty(), new SimpleDoubleProperty(), 158 new Functions<Number>() { 159 @Override 160 public Binding<Number> create(Callable func, Observable... dependencies) { 161 return Bindings.createDoubleBinding(func, dependencies); 162 } 163 164 @Override 165 public void check(Number value0, Number value1) { 166 assertEquals(value0.doubleValue(), value1.doubleValue(), EPSILON_DOUBLE); 167 } 168 }, 169 Math.PI, -Math.E, 0.0 170 }, 171 { 172 new SimpleFloatProperty(), new SimpleFloatProperty(), 173 new Functions<Number>() { 174 @Override 175 public Binding<Number> create(Callable func, Observable... dependencies) { 176 return Bindings.createFloatBinding(func, dependencies); 177 } 178 179 @Override 180 public void check(Number value0, Number value1) { 181 assertEquals(value0.floatValue(), value1.floatValue(), EPSILON_FLOAT); 182 } 183 }, 184 (float)Math.PI, (float)-Math.E, 0.0f 185 }, 186 { 187 new SimpleIntegerProperty(), new SimpleIntegerProperty(), 188 new Functions<Number>() { 189 @Override 190 public Binding<Number> create(Callable func, Observable... dependencies) { 191 return Bindings.createIntegerBinding(func, dependencies); 192 } 193 194 @Override 195 public void check(Number value0, Number value1) { 196 assertEquals(value0.intValue(), value1.intValue()); 197 } 198 }, 199 Integer.MAX_VALUE, Integer.MIN_VALUE, 0 200 }, 201 { 202 new SimpleLongProperty(), new SimpleLongProperty(), 203 new Functions<Number>() { 204 @Override 205 public Binding<Number> create(Callable func, Observable... dependencies) { 206 return Bindings.createLongBinding(func, dependencies); 207 } 208 209 @Override 210 public void check(Number value0, Number value1) { 211 assertEquals(value0.longValue(), value1.longValue()); 212 } 213 }, 214 Long.MAX_VALUE, Long.MIN_VALUE, 0L 215 }, 216 { 217 new SimpleObjectProperty(), new SimpleObjectProperty(), 218 new Functions<Object>() { 219 @Override 220 public Binding<Object> create(Callable<Object> func, Observable... dependencies) { 221 return Bindings.createObjectBinding(func, dependencies); 222 } 223 224 @Override 225 public void check(Object value0, Object value1) { 226 assertEquals(value0, value1); 227 } 228 }, 229 new Object(), new Object(), null 230 }, 231 { 232 new SimpleStringProperty(), new SimpleStringProperty(), 233 new Functions<String>() { 234 @Override 235 public Binding<String> create(Callable<String> func, Observable... dependencies) { 236 return Bindings.createStringBinding(func, dependencies); 237 } 238 239 @Override 240 public void check(String value0, String value1) { 241 assertEquals(value0, value1); 242 } 243 }, 244 "Hello World", "Goodbye World", "" 245 }, 246 }); 247 } 248 }