1 /*
2 * Copyright (c) 2011, 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 javafx.binding;
27
28 import static org.junit.Assert.assertEquals;
29 import static org.junit.Assert.assertTrue;
30
31 import java.util.Arrays;
32 import java.util.Collection;
33
34 import javafx.beans.binding.Binding;
35 import javafx.beans.binding.Bindings;
36 import javafx.beans.binding.BooleanExpression;
37 import javafx.beans.binding.DoubleExpression;
38 import javafx.beans.binding.FloatExpression;
39 import javafx.beans.binding.IntegerExpression;
40 import javafx.beans.binding.LongExpression;
41 import javafx.beans.binding.NumberExpression;
42 import javafx.beans.property.DoubleProperty;
43 import javafx.beans.property.FloatProperty;
44 import javafx.beans.property.IntegerProperty;
45 import javafx.beans.property.LongProperty;
46 import javafx.beans.property.SimpleDoubleProperty;
47 import javafx.beans.property.SimpleFloatProperty;
48 import javafx.beans.property.SimpleIntegerProperty;
49 import javafx.beans.property.SimpleLongProperty;
50 import javafx.beans.value.ObservableNumberValue;
51
52 import org.junit.Before;
53 import org.junit.Test;
54 import org.junit.runner.RunWith;
55 import org.junit.runners.Parameterized;
56
57 @RunWith(Parameterized.class)
58 public class BindingsNumberCastTest {
59
60 public static interface Functions {
61 Binding generateExpression(ObservableNumberValue op1, ObservableNumberValue op2);
62 void check(double op1, double op2, Binding binding);
63 }
64
65 private static final double EPSILON = 1e-5;
66
67 private final Functions func;
68
69 private Double double0;
70 private Float float0;
71 private Long long0;
72 private Integer integer0;
73
74 private DoubleProperty double1;
75 private FloatProperty float1;
76 private LongProperty long1;
77 private IntegerProperty integer1;
78
79 public BindingsNumberCastTest(Functions func) {
80 this.func = func;
81 }
82
83 @Before
84 public void setUp() {
85 double0 = Double.valueOf(3.1415);
86 float0 = Float.valueOf(2.71f);
87 long0 = Long.valueOf(111L);
88 integer0 = Integer.valueOf(42);
89
90 double1 = new SimpleDoubleProperty(double0);
91 float1 = new SimpleFloatProperty(float0);
92 long1 = new SimpleLongProperty(long0);
93 integer1 = new SimpleIntegerProperty(integer0);
94 }
95
96 @Test
97 public void testDouble() {
98 Binding binding = func.generateExpression(double1, double1);
99 assertTrue(binding instanceof DoubleExpression || binding instanceof BooleanExpression);
100 func.check(double0, double0, binding);
101
102 binding = func.generateExpression(double1, float1);
103 assertTrue(binding instanceof DoubleExpression || binding instanceof BooleanExpression);
104 func.check(double0, float0, binding);
105
106 binding = func.generateExpression(double1, long1);
107 assertTrue(binding instanceof DoubleExpression || binding instanceof BooleanExpression);
108 func.check(double0, long0, binding);
109
110 binding = func.generateExpression(double1, integer1);
111 assertTrue(binding instanceof DoubleExpression || binding instanceof BooleanExpression);
112 func.check(double0, integer0, binding);
113 }
114
115 @Test
116 public void testFloat() {
117 Binding binding = func.generateExpression(float1, double1);
118 assertTrue(binding instanceof DoubleExpression || binding instanceof BooleanExpression);
119 func.check(float0, double0, binding);
120
121 binding = func.generateExpression(float1, float1);
122 assertTrue(binding instanceof FloatExpression || binding instanceof BooleanExpression);
123 func.check(float0, float0, binding);
124
125 binding = func.generateExpression(float1, long1);
126 assertTrue(binding instanceof FloatExpression || binding instanceof BooleanExpression);
127 func.check(float0, long0, binding);
128
129 binding = func.generateExpression(float1, integer1);
130 assertTrue(binding instanceof FloatExpression || binding instanceof BooleanExpression);
131 func.check(float0, integer0, binding);
132 }
133
134 @Test
135 public void testLong() {
136 Binding binding = func.generateExpression(long1, double1);
137 assertTrue(binding instanceof DoubleExpression || binding instanceof BooleanExpression);
138 func.check(long0, double0, binding);
139
140 binding = func.generateExpression(long1, float1);
141 assertTrue(binding instanceof FloatExpression || binding instanceof BooleanExpression);
142 func.check(long0, float0, binding);
143
144 binding = func.generateExpression(long1, long1);
145 assertTrue(binding instanceof LongExpression || binding instanceof BooleanExpression);
146 func.check(long0, long0, binding);
147
148 binding = func.generateExpression(long1, integer1);
149 assertTrue(binding instanceof LongExpression || binding instanceof BooleanExpression);
150 func.check(long0, integer0, binding);
151 }
152
153 @Test
154 public void testInteger() {
155 Binding binding = func.generateExpression(integer1, double1);
156 assertTrue(binding instanceof DoubleExpression || binding instanceof BooleanExpression);
157 func.check(integer0, double0, binding);
158
159 binding = func.generateExpression(integer1, float1);
160 assertTrue(binding instanceof FloatExpression || binding instanceof BooleanExpression);
161 func.check(integer0, float0, binding);
162
163 binding = func.generateExpression(integer1, long1);
164 assertTrue(binding instanceof LongExpression || binding instanceof BooleanExpression);
165 func.check(integer0, long0, binding);
166
167 binding = func.generateExpression(integer1, integer1);
168 assertTrue(binding instanceof IntegerExpression || binding instanceof BooleanExpression);
169 func.check(integer0, integer0, binding);
170 }
171
172 @Parameterized.Parameters
173 public static Collection<Object[]> parameters() {
174 return Arrays.asList(new Object[][] {
175 {
176 new Functions() {
177 @Override
178 public Binding generateExpression(ObservableNumberValue op1, ObservableNumberValue op2) {
179 return Bindings.add(op1, op2);
180 }
181
182 @Override
183 public void check(double op1, double op2, Binding binding) {
184 assertTrue(binding instanceof NumberExpression);
185 assertEquals(op1 + op2, ((NumberExpression)binding).doubleValue(), EPSILON);
186 }
187
188 }
189 },
190 {
191 new Functions() {
192 @Override
193 public Binding generateExpression(ObservableNumberValue op1, ObservableNumberValue op2) {
194 return Bindings.multiply(op1, op2);
195 }
196
197 @Override
198 public void check(double op1, double op2, Binding binding) {
199 assertTrue(binding instanceof NumberExpression);
200 assertEquals(op1 * op2, ((NumberExpression)binding).doubleValue(), EPSILON);
201 }
202
203 }
204 },
205 {
206 new Functions() {
207 @Override
208 public Binding generateExpression(ObservableNumberValue op1, ObservableNumberValue op2) {
209 return Bindings.divide(op1, op2);
210 }
211
212 @Override
213 public void check(double op1, double op2, Binding binding) {
214 assertTrue(binding instanceof NumberExpression);
215 if ((binding instanceof DoubleExpression) || (binding instanceof FloatExpression)) {
216 assertEquals(op1 / op2, ((NumberExpression)binding).doubleValue(), EPSILON);
217 } else {
218 assertEquals((long)op1 / (long)op2, ((NumberExpression)binding).longValue());
219 }
220 }
221
222 }
223 },
224 {
225 new Functions() {
226 @Override
227 public Binding generateExpression(ObservableNumberValue op1, ObservableNumberValue op2) {
228 return Bindings.min(op1, op2);
229 }
230
231 @Override
232 public void check(double op1, double op2, Binding binding) {
233 assertTrue(binding instanceof NumberExpression);
234 assertEquals(Math.min(op1, op2), ((NumberExpression)binding).doubleValue(), EPSILON);
235 }
236
237 }
238 },
239 {
240 new Functions() {
241 @Override
242 public Binding generateExpression(ObservableNumberValue op1, ObservableNumberValue op2) {
243 return Bindings.max(op1, op2);
244 }
245
246 @Override
247 public void check(double op1, double op2, Binding binding) {
248 assertTrue(binding instanceof NumberExpression);
249 assertEquals(Math.max(op1, op2), ((NumberExpression)binding).doubleValue(), EPSILON);
250 }
251
252 }
253 },
254 {
255 new Functions() {
256 @Override
257 public Binding generateExpression(ObservableNumberValue op1, ObservableNumberValue op2) {
258 return Bindings.equal(op1, op2);
259 }
260
261 @Override
262 public void check(double op1, double op2, Binding binding) {
263 assertTrue(binding instanceof BooleanExpression);
264 assertEquals(Math.abs(op1 - op2) < EPSILON, ((BooleanExpression)binding).get());
265 }
266
267 }
268 },
269 {
270 new Functions() {
271 @Override
272 public Binding generateExpression(ObservableNumberValue op1, ObservableNumberValue op2) {
273 return Bindings.greaterThan(op1, op2);
274 }
275
276 @Override
277 public void check(double op1, double op2, Binding binding) {
278 assertTrue(binding instanceof BooleanExpression);
279 assertEquals(op1 > op2, ((BooleanExpression)binding).get());
280 }
281
282 }
283 },
284 });
285 }
286
287 }