1 /*
2 * Copyright (c) 2010, 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
30 import java.util.Arrays;
31 import java.util.Collection;
32
33 import javafx.beans.InvalidationListenerMock;
34 import javafx.beans.binding.Binding;
35 import javafx.beans.binding.Bindings;
36 import javafx.beans.property.DoubleProperty;
37 import javafx.beans.property.FloatProperty;
38 import javafx.beans.property.IntegerProperty;
39 import javafx.beans.property.LongProperty;
40 import javafx.beans.property.SimpleDoubleProperty;
41 import javafx.beans.property.SimpleFloatProperty;
42 import javafx.beans.property.SimpleIntegerProperty;
43 import javafx.beans.property.SimpleLongProperty;
44 import javafx.beans.value.*;
45
46 import org.junit.Before;
47 import org.junit.Test;
48 import org.junit.runner.RunWith;
49 import org.junit.runners.Parameterized;
50
51 @RunWith(Parameterized.class)
52 public class BindingsNumberCalculationsTest<T> {
53
54 private static final float EPSILON_FLOAT = 1e-5f;
55 private static final double EPSILON_DOUBLE = 1e-10;
56
57 public static interface Functions<S> {
58 Binding generateExpressionExpression(Object op1, Object op2);
59 Binding generateExpressionPrimitive(Object op1, S op2);
60 Binding generatePrimitiveExpression(S op1, Object op2);
61 void setOp1(S value);
62 void setOp2(S value);
63 void check(S op1, S op2, ObservableValue exp);
64 }
65
66 private final ObservableValue op1;
67 private final ObservableValue op2;
68 private final Functions<T> func;
69 private final T[] v;
70 private InvalidationListenerMock observer;
71
72 public BindingsNumberCalculationsTest(ObservableValue op1, ObservableValue op2, Functions<T> func, T[] v) {
73 this.op1 = op1;
74 this.op2 = op2;
75 this.func = func;
76 this.v = v;
77 }
78
79 @Before
80 public void setUp() {
81 func.setOp1(v[0]);
82 func.setOp2(v[1]);
83 observer = new InvalidationListenerMock();
84 }
85
86 @Test
87 public void test_Expression_Expression() {
88 final Binding binding = func.generateExpressionExpression(op1, op2);
89 binding.addListener(observer);
90
91 // check initial value
92 func.check(v[0], v[1], binding);
93 DependencyUtils.checkDependencies(binding.getDependencies(), op1, op2);
94
95 // change first operand
96 observer.reset();
97 func.setOp1(v[2]);
98 func.check(v[2], v[1], binding);
99 observer.check(binding, 1);
100
101 // change second operand
102 func.setOp2(v[3]);
103 func.check(v[2], v[3], binding);
104 observer.check(binding, 1);
105
106 // change both operands
107 func.setOp1(v[4]);
108 func.setOp2(v[5]);
109 func.check(v[4], v[5], binding);
110 observer.check(binding, 1);
111 }
112
113 @Test
114 public void test_Self() {
115 // using same FloatValue twice
116 final Binding binding = func.generateExpressionExpression(op1, op1);
117 binding.addListener(observer);
118
119 // check initial value
120 func.check(v[0], v[0], binding);
121
122 // change value
123 observer.reset();
124 func.setOp1(v[7]);
125 func.check(v[7], v[7], binding);
126 observer.check(binding, 1);
127 }
128
129 @Test(expected=NullPointerException.class)
130 public void test_null_Expression() {
131 func.generateExpressionExpression(null, op1);
132 }
133
134 @Test(expected=NullPointerException.class)
135 public void test_Expression_null() {
136 func.generateExpressionExpression(op1, null);
137 }
138
139 @Test
140 public void test_Expression_Primitive() {
141 final Binding binding = func.generateExpressionPrimitive(op1, v[7]);
142 binding.addListener(observer);
143
144 // check initial value
145 func.check(v[0], v[7], binding);
146 DependencyUtils.checkDependencies(binding.getDependencies(), op1);
147
148 // change first operand
149 observer.reset();
150 func.setOp1(v[8]);
151 func.check(v[8], v[7], binding);
152 observer.check(binding, 1);
153 }
154
155 @Test(expected=NullPointerException.class)
156 public void test_null_Primitive() {
157 func.generateExpressionPrimitive(null, v[0]);
158 }
159
160 @Test
161 public void test_Primitive_Expression() {
162 final Binding binding = func.generatePrimitiveExpression(v[9], op1);
163 binding.addListener(observer);
164
165 // check initial value
166 func.check(v[9], v[0], binding);
167 DependencyUtils.checkDependencies(binding.getDependencies(), op1);
168
169 // change first operand
170 observer.reset();
171 func.setOp1(v[10]);
172 func.check(v[9], v[10], binding);
173 observer.check(binding, 1);
174 }
175
176 @Test(expected=NullPointerException.class)
177 public void test_Primitive_null() {
178 func.generatePrimitiveExpression(v[0], null);
179 }
180
181 @Parameterized.Parameters
182 public static Collection<Object[]> parameters() {
183 final FloatProperty float1 = new SimpleFloatProperty();
184 final FloatProperty float2 = new SimpleFloatProperty();
185 final Float[] floatData = new Float[] {-3592.9f, 234872.8347f, 3897.274f, 3958.938745f, -8347.3478f, 217.902874f, -2784.827f, -28723.7824f, 82.8274f, -12.23478f, 0.92874f};
186
187 final DoubleProperty double1 = new SimpleDoubleProperty();
188 final DoubleProperty double2 = new SimpleDoubleProperty();
189 final Double[] doubleData = new Double[] {2348.2345, -92.214, -214.0214, -908.214, 67.124, 0.214, 2893.124, -214.987234, -89724.897234, 234.25, 8721.234};
190
191 final IntegerProperty int1 = new SimpleIntegerProperty();
192 final IntegerProperty int2 = new SimpleIntegerProperty();
193 final Integer[] integerData = new Integer[] {248, -9384, -234, -34, -450809, 342345, 8923489, 23789, -89234, -13134, 23134879};
194
195 final LongProperty long1 = new SimpleLongProperty();
196 final LongProperty long2 = new SimpleLongProperty();
197 final Long[] longData = new Long[] {9823984L, 2908934L, -234234L, 9089234L, 132323L, -89324L, -12424L, -8923442L, 78234L, -233487L, 988998L};
198
199 return Arrays.asList(new Object[][] {
200 // float
201 {
202 float1, float2,
203 new Functions<Float>() {
204 @Override
205 public Binding generateExpressionExpression(Object op1, Object op2) {
206 return Bindings.add((ObservableFloatValue)op1, (ObservableFloatValue)op2);
207 }
208 @Override
209 public Binding generateExpressionPrimitive(Object op1, Float op2) {
210 return Bindings.add((ObservableFloatValue)op1, op2.floatValue());
211 }
212 @Override
213 public Binding generatePrimitiveExpression(Float op1, Object op2) {
214 return Bindings.add(op1.floatValue(), (ObservableFloatValue)op2);
215 }
216 @Override
217 public void setOp1(Float value) {float1.set(value);}
218 @Override
219 public void setOp2(Float value) {float2.set(value);}
220 @Override
221 public void check(Float op1, Float op2, ObservableValue exp) {
222 assertEquals(op1 + op2, ((ObservableFloatValue)exp).get(), EPSILON_FLOAT);
223 }
224 },
225 floatData
226 },
227 {
228 float1, float2,
229 new Functions<Float>() {
230 @Override
231 public Binding generateExpressionExpression(Object op1, Object op2) {
232 return Bindings.subtract((ObservableFloatValue)op1, (ObservableFloatValue)op2);
233 }
234 @Override
235 public Binding generateExpressionPrimitive(Object op1, Float op2) {
236 return Bindings.subtract((ObservableFloatValue)op1, op2.floatValue());
237 }
238 @Override
239 public Binding generatePrimitiveExpression(Float op1, Object op2) {
240 return Bindings.subtract(op1.floatValue(), (ObservableFloatValue)op2);
241 }
242 @Override
243 public void setOp1(Float value) {float1.set(value);}
244 @Override
245 public void setOp2(Float value) {float2.set(value);}
246 @Override
247 public void check(Float op1, Float op2, ObservableValue exp) {
248 assertEquals(op1 - op2, ((ObservableFloatValue)exp).get(), EPSILON_FLOAT);
249 }
250 },
251 floatData
252 },
253 {
254 float1, float2,
255 new Functions<Float>() {
256 @Override
257 public Binding generateExpressionExpression(Object op1, Object op2) {
258 return Bindings.multiply((ObservableFloatValue)op1, (ObservableFloatValue)op2);
259 }
260 @Override
261 public Binding generateExpressionPrimitive(Object op1, Float op2) {
262 return Bindings.multiply((ObservableFloatValue)op1, op2.floatValue());
263 }
264 @Override
265 public Binding generatePrimitiveExpression(Float op1, Object op2) {
266 return Bindings.multiply(op1.floatValue(), (ObservableFloatValue)op2);
267 }
268 @Override
269 public void setOp1(Float value) {float1.set(value);}
270 @Override
271 public void setOp2(Float value) {float2.set(value);}
272 @Override
273 public void check(Float op1, Float op2, ObservableValue exp) {
274 assertEquals(op1 * op2, ((ObservableFloatValue)exp).get(), EPSILON_FLOAT);
275 }
276 },
277 floatData
278 },
279 {
280 float1, float2,
281 new Functions<Float>() {
282 @Override
283 public Binding generateExpressionExpression(Object op1, Object op2) {
284 return Bindings.divide((ObservableFloatValue)op1, (ObservableFloatValue)op2);
285 }
286 @Override
287 public Binding generateExpressionPrimitive(Object op1, Float op2) {
288 return Bindings.divide((ObservableFloatValue)op1, op2.floatValue());
289 }
290 @Override
291 public Binding generatePrimitiveExpression(Float op1, Object op2) {
292 return Bindings.divide(op1.floatValue(), (ObservableFloatValue)op2);
293 }
294 @Override
295 public void setOp1(Float value) {float1.set(value);}
296 @Override
297 public void setOp2(Float value) {float2.set(value);}
298 @Override
299 public void check(Float op1, Float op2, ObservableValue exp) {
300 assertEquals(op1 / op2, ((ObservableFloatValue)exp).get(), EPSILON_FLOAT);
301 }
302 },
303 floatData
304 },
305 {
306 float1, float2,
307 new Functions<Float>() {
308 @Override
309 public Binding generateExpressionExpression(Object op1, Object op2) {
310 return Bindings.min((ObservableFloatValue)op1, (ObservableFloatValue)op2);
311 }
312 @Override
313 public Binding generateExpressionPrimitive(Object op1, Float op2) {
314 return Bindings.min((ObservableFloatValue)op1, op2.floatValue());
315 }
316 @Override
317 public Binding generatePrimitiveExpression(Float op1, Object op2) {
318 return Bindings.min(op1.floatValue(), (ObservableFloatValue)op2);
319 }
320 @Override
321 public void setOp1(Float value) {float1.set(value);}
322 @Override
323 public void setOp2(Float value) {float2.set(value);}
324 @Override
325 public void check(Float op1, Float op2, ObservableValue exp) {
326 assertEquals(Math.min(op1, op2), ((ObservableFloatValue)exp).get(), EPSILON_FLOAT);
327 }
328 },
329 floatData
330 },
331 {
332 float1, float2,
333 new Functions<Float>() {
334 @Override
335 public Binding generateExpressionExpression(Object op1, Object op2) {
336 return Bindings.max((ObservableFloatValue)op1, (ObservableFloatValue)op2);
337 }
338 @Override
339 public Binding generateExpressionPrimitive(Object op1, Float op2) {
340 return Bindings.max((ObservableFloatValue)op1, op2.floatValue());
341 }
342 @Override
343 public Binding generatePrimitiveExpression(Float op1, Object op2) {
344 return Bindings.max(op1.floatValue(), (ObservableFloatValue)op2);
345 }
346 @Override
347 public void setOp1(Float value) {float1.set(value);}
348 @Override
349 public void setOp2(Float value) {float2.set(value);}
350 @Override
351 public void check(Float op1, Float op2, ObservableValue exp) {
352 assertEquals(Math.max(op1, op2), ((ObservableFloatValue)exp).get(), EPSILON_FLOAT);
353 }
354 },
355 floatData
356 },
357
358
359
360 // double
361 {
362 double1, double2,
363 new Functions<Double>() {
364 @Override
365 public Binding generateExpressionExpression(Object op1, Object op2) {
366 return Bindings.add((ObservableDoubleValue)op1, (ObservableDoubleValue)op2);
367 }
368 @Override
369 public Binding generateExpressionPrimitive(Object op1, Double op2) {
370 return Bindings.add((ObservableDoubleValue)op1, op2.doubleValue());
371 }
372 @Override
373 public Binding generatePrimitiveExpression(Double op1, Object op2) {
374 return Bindings.add(op1.doubleValue(), (ObservableDoubleValue)op2);
375 }
376 @Override
377 public void setOp1(Double value) {double1.set(value);}
378 @Override
379 public void setOp2(Double value) {double2.set(value);}
380 @Override
381 public void check(Double op1, Double op2, ObservableValue exp) {
382 assertEquals(op1 + op2, ((ObservableDoubleValue)exp).get(), EPSILON_DOUBLE);
383 }
384 },
385 doubleData
386 },
387 {
388 double1, double2,
389 new Functions<Double>() {
390 @Override
391 public Binding generateExpressionExpression(Object op1, Object op2) {
392 return Bindings.subtract((ObservableDoubleValue)op1, (ObservableDoubleValue)op2);
393 }
394 @Override
395 public Binding generateExpressionPrimitive(Object op1, Double op2) {
396 return Bindings.subtract((ObservableDoubleValue)op1, op2.doubleValue());
397 }
398 @Override
399 public Binding generatePrimitiveExpression(Double op1, Object op2) {
400 return Bindings.subtract(op1.doubleValue(), (ObservableDoubleValue)op2);
401 }
402 @Override
403 public void setOp1(Double value) {double1.set(value);}
404 @Override
405 public void setOp2(Double value) {double2.set(value);}
406 @Override
407 public void check(Double op1, Double op2, ObservableValue exp) {
408 assertEquals(op1 - op2, ((ObservableDoubleValue)exp).get(), EPSILON_DOUBLE);
409 }
410 },
411 doubleData
412 },
413 {
414 double1, double2,
415 new Functions<Double>() {
416 @Override
417 public Binding generateExpressionExpression(Object op1, Object op2) {
418 return Bindings.multiply((ObservableDoubleValue)op1, (ObservableDoubleValue)op2);
419 }
420 @Override
421 public Binding generateExpressionPrimitive(Object op1, Double op2) {
422 return Bindings.multiply((ObservableDoubleValue)op1, op2.doubleValue());
423 }
424 @Override
425 public Binding generatePrimitiveExpression(Double op1, Object op2) {
426 return Bindings.multiply(op1.doubleValue(), (ObservableDoubleValue)op2);
427 }
428 @Override
429 public void setOp1(Double value) {double1.set(value);}
430 @Override
431 public void setOp2(Double value) {double2.set(value);}
432 @Override
433 public void check(Double op1, Double op2, ObservableValue exp) {
434 assertEquals(op1 * op2, ((ObservableDoubleValue)exp).get(), EPSILON_DOUBLE);
435 }
436 },
437 doubleData
438 },
439 {
440 double1, double2,
441 new Functions<Double>() {
442 @Override
443 public Binding generateExpressionExpression(Object op1, Object op2) {
444 return Bindings.divide((ObservableDoubleValue)op1, (ObservableDoubleValue)op2);
445 }
446 @Override
447 public Binding generateExpressionPrimitive(Object op1, Double op2) {
448 return Bindings.divide((ObservableDoubleValue)op1, op2.doubleValue());
449 }
450 @Override
451 public Binding generatePrimitiveExpression(Double op1, Object op2) {
452 return Bindings.divide(op1.doubleValue(), (ObservableDoubleValue)op2);
453 }
454 @Override
455 public void setOp1(Double value) {double1.set(value);}
456 @Override
457 public void setOp2(Double value) {double2.set(value);}
458 @Override
459 public void check(Double op1, Double op2, ObservableValue exp) {
460 assertEquals(op1 / op2, ((ObservableDoubleValue)exp).get(), EPSILON_DOUBLE);
461 }
462 },
463 doubleData
464 },
465 {
466 double1, double2,
467 new Functions<Double>() {
468 @Override
469 public Binding generateExpressionExpression(Object op1, Object op2) {
470 return Bindings.min((ObservableDoubleValue)op1, (ObservableDoubleValue)op2);
471 }
472 @Override
473 public Binding generateExpressionPrimitive(Object op1, Double op2) {
474 return Bindings.min((ObservableDoubleValue)op1, op2.doubleValue());
475 }
476 @Override
477 public Binding generatePrimitiveExpression(Double op1, Object op2) {
478 return Bindings.min(op1.doubleValue(), (ObservableDoubleValue)op2);
479 }
480 @Override
481 public void setOp1(Double value) {double1.set(value);}
482 @Override
483 public void setOp2(Double value) {double2.set(value);}
484 @Override
485 public void check(Double op1, Double op2, ObservableValue exp) {
486 assertEquals(Math.min(op1, op2), ((ObservableDoubleValue)exp).get(), EPSILON_DOUBLE);
487 }
488 },
489 doubleData
490 },
491 {
492 double1, double2,
493 new Functions<Double>() {
494 @Override
495 public Binding generateExpressionExpression(Object op1, Object op2) {
496 return Bindings.max((ObservableDoubleValue)op1, (ObservableDoubleValue)op2);
497 }
498 @Override
499 public Binding generateExpressionPrimitive(Object op1, Double op2) {
500 return Bindings.max((ObservableDoubleValue)op1, op2.doubleValue());
501 }
502 @Override
503 public Binding generatePrimitiveExpression(Double op1, Object op2) {
504 return Bindings.max(op1.doubleValue(), (ObservableDoubleValue)op2);
505 }
506 @Override
507 public void setOp1(Double value) {double1.set(value);}
508 @Override
509 public void setOp2(Double value) {double2.set(value);}
510 @Override
511 public void check(Double op1, Double op2, ObservableValue exp) {
512 assertEquals(Math.max(op1, op2), ((ObservableDoubleValue)exp).get(), EPSILON_DOUBLE);
513 }
514 },
515 doubleData
516 },
517
518
519
520 // int
521 {
522 int1, int2,
523 new Functions<Integer>() {
524 @Override
525 public Binding generateExpressionExpression(Object op1, Object op2) {
526 return Bindings.add((ObservableIntegerValue)op1, (ObservableIntegerValue)op2);
527 }
528 @Override
529 public Binding generateExpressionPrimitive(Object op1, Integer op2) {
530 return Bindings.add((ObservableIntegerValue)op1, op2.intValue());
531 }
532 @Override
533 public Binding generatePrimitiveExpression(Integer op1, Object op2) {
534 return Bindings.add(op1.intValue(), (ObservableIntegerValue)op2);
535 }
536 @Override
537 public void setOp1(Integer value) {int1.set(value);}
538 @Override
539 public void setOp2(Integer value) {int2.set(value);}
540 @Override
541 public void check(Integer op1, Integer op2, ObservableValue exp) {
542 assertEquals(op1 + op2, ((ObservableIntegerValue)exp).get());
543 }
544 },
545 integerData
546 },
547 {
548 int1, int2,
549 new Functions<Integer>() {
550 @Override
551 public Binding generateExpressionExpression(Object op1, Object op2) {
552 return Bindings.subtract((ObservableIntegerValue)op1, (ObservableIntegerValue)op2);
553 }
554 @Override
555 public Binding generateExpressionPrimitive(Object op1, Integer op2) {
556 return Bindings.subtract((ObservableIntegerValue)op1, op2.intValue());
557 }
558 @Override
559 public Binding generatePrimitiveExpression(Integer op1, Object op2) {
560 return Bindings.subtract(op1.intValue(), (ObservableIntegerValue)op2);
561 }
562 @Override
563 public void setOp1(Integer value) {int1.set(value);}
564 @Override
565 public void setOp2(Integer value) {int2.set(value);}
566 @Override
567 public void check(Integer op1, Integer op2, ObservableValue exp) {
568 assertEquals(op1 - op2, ((ObservableIntegerValue)exp).get());
569 }
570 },
571 integerData
572 },
573 {
574 int1, int2,
575 new Functions<Integer>() {
576 @Override
577 public Binding generateExpressionExpression(Object op1, Object op2) {
578 return Bindings.multiply((ObservableIntegerValue)op1, (ObservableIntegerValue)op2);
579 }
580 @Override
581 public Binding generateExpressionPrimitive(Object op1, Integer op2) {
582 return Bindings.multiply((ObservableIntegerValue)op1, op2.intValue());
583 }
584 @Override
585 public Binding generatePrimitiveExpression(Integer op1, Object op2) {
586 return Bindings.multiply(op1.intValue(), (ObservableIntegerValue)op2);
587 }
588 @Override
589 public void setOp1(Integer value) {int1.set(value);}
590 @Override
591 public void setOp2(Integer value) {int2.set(value);}
592 @Override
593 public void check(Integer op1, Integer op2, ObservableValue exp) {
594 assertEquals(op1 * op2, ((ObservableIntegerValue)exp).get());
595 }
596 },
597 integerData
598 },
599 {
600 int1, int2,
601 new Functions<Integer>() {
602 @Override
603 public Binding generateExpressionExpression(Object op1, Object op2) {
604 return Bindings.divide((ObservableIntegerValue)op1, (ObservableIntegerValue)op2);
605 }
606 @Override
607 public Binding generateExpressionPrimitive(Object op1, Integer op2) {
608 return Bindings.divide((ObservableIntegerValue)op1, op2.intValue());
609 }
610 @Override
611 public Binding generatePrimitiveExpression(Integer op1, Object op2) {
612 return Bindings.divide(op1.intValue(), (ObservableIntegerValue)op2);
613 }
614 @Override
615 public void setOp1(Integer value) {int1.set(value);}
616 @Override
617 public void setOp2(Integer value) {int2.set(value);}
618 @Override
619 public void check(Integer op1, Integer op2, ObservableValue exp) {
620 assertEquals(op1 / op2, ((ObservableIntegerValue)exp).get());
621 }
622 },
623 integerData
624 },
625 {
626 int1, int2,
627 new Functions<Integer>() {
628 @Override
629 public Binding generateExpressionExpression(Object op1, Object op2) {
630 return Bindings.min((ObservableIntegerValue)op1, (ObservableIntegerValue)op2);
631 }
632 @Override
633 public Binding generateExpressionPrimitive(Object op1, Integer op2) {
634 return Bindings.min((ObservableIntegerValue)op1, op2.intValue());
635 }
636 @Override
637 public Binding generatePrimitiveExpression(Integer op1, Object op2) {
638 return Bindings.min(op1.intValue(), (ObservableIntegerValue)op2);
639 }
640 @Override
641 public void setOp1(Integer value) {int1.set(value);}
642 @Override
643 public void setOp2(Integer value) {int2.set(value);}
644 @Override
645 public void check(Integer op1, Integer op2, ObservableValue exp) {
646 assertEquals(Math.min(op1, op2), ((ObservableIntegerValue)exp).get());
647 }
648 },
649 integerData
650 },
651 {
652 int1, int2,
653 new Functions<Integer>() {
654 @Override
655 public Binding generateExpressionExpression(Object op1, Object op2) {
656 return Bindings.max((ObservableIntegerValue)op1, (ObservableIntegerValue)op2);
657 }
658 @Override
659 public Binding generateExpressionPrimitive(Object op1, Integer op2) {
660 return Bindings.max((ObservableIntegerValue)op1, op2.intValue());
661 }
662 @Override
663 public Binding generatePrimitiveExpression(Integer op1, Object op2) {
664 return Bindings.max(op1.intValue(), (ObservableIntegerValue)op2);
665 }
666 @Override
667 public void setOp1(Integer value) {int1.set(value);}
668 @Override
669 public void setOp2(Integer value) {int2.set(value);}
670 @Override
671 public void check(Integer op1, Integer op2, ObservableValue exp) {
672 assertEquals(Math.max(op1, op2), ((ObservableIntegerValue)exp).get());
673 }
674 },
675 integerData
676 },
677
678
679
680 // long
681 {
682 long1, long2,
683 new Functions<Long>() {
684 @Override
685 public Binding generateExpressionExpression(Object op1, Object op2) {
686 return Bindings.add((ObservableLongValue)op1, (ObservableLongValue)op2);
687 }
688 @Override
689 public Binding generateExpressionPrimitive(Object op1, Long op2) {
690 return Bindings.add((ObservableLongValue)op1, op2.longValue());
691 }
692 @Override
693 public Binding generatePrimitiveExpression(Long op1, Object op2) {
694 return Bindings.add(op1.longValue(), (ObservableLongValue)op2);
695 }
696 @Override
697 public void setOp1(Long value) {long1.set(value);}
698 @Override
699 public void setOp2(Long value) {long2.set(value);}
700 @Override
701 public void check(Long op1, Long op2, ObservableValue exp) {
702 assertEquals(op1 + op2, ((ObservableLongValue)exp).get());
703 }
704 },
705 longData
706 },
707 {
708 long1, long2,
709 new Functions<Long>() {
710 @Override
711 public Binding generateExpressionExpression(Object op1, Object op2) {
712 return Bindings.subtract((ObservableLongValue)op1, (ObservableLongValue)op2);
713 }
714 @Override
715 public Binding generateExpressionPrimitive(Object op1, Long op2) {
716 return Bindings.subtract((ObservableLongValue)op1, op2.longValue());
717 }
718 @Override
719 public Binding generatePrimitiveExpression(Long op1, Object op2) {
720 return Bindings.subtract(op1.longValue(), (ObservableLongValue)op2);
721 }
722 @Override
723 public void setOp1(Long value) {long1.set(value);}
724 @Override
725 public void setOp2(Long value) {long2.set(value);}
726 @Override
727 public void check(Long op1, Long op2, ObservableValue exp) {
728 assertEquals(op1 - op2, ((ObservableLongValue)exp).get());
729 }
730 },
731 longData
732 },
733 {
734 long1, long2,
735 new Functions<Long>() {
736 @Override
737 public Binding generateExpressionExpression(Object op1, Object op2) {
738 return Bindings.multiply((ObservableLongValue)op1, (ObservableLongValue)op2);
739 }
740 @Override
741 public Binding generateExpressionPrimitive(Object op1, Long op2) {
742 return Bindings.multiply((ObservableLongValue)op1, op2.longValue());
743 }
744 @Override
745 public Binding generatePrimitiveExpression(Long op1, Object op2) {
746 return Bindings.multiply(op1.longValue(), (ObservableLongValue)op2);
747 }
748 @Override
749 public void setOp1(Long value) {long1.set(value);}
750 @Override
751 public void setOp2(Long value) {long2.set(value);}
752 @Override
753 public void check(Long op1, Long op2, ObservableValue exp) {
754 assertEquals(op1 * op2, ((ObservableLongValue)exp).get());
755 }
756 },
757 longData
758 },
759 {
760 long1, long2,
761 new Functions<Long>() {
762 @Override
763 public Binding generateExpressionExpression(Object op1, Object op2) {
764 return Bindings.divide((ObservableLongValue)op1, (ObservableLongValue)op2);
765 }
766 @Override
767 public Binding generateExpressionPrimitive(Object op1, Long op2) {
768 return Bindings.divide((ObservableLongValue)op1, op2.longValue());
769 }
770 @Override
771 public Binding generatePrimitiveExpression(Long op1, Object op2) {
772 return Bindings.divide(op1.longValue(), (ObservableLongValue)op2);
773 }
774 @Override
775 public void setOp1(Long value) {long1.set(value);}
776 @Override
777 public void setOp2(Long value) {long2.set(value);}
778 @Override
779 public void check(Long op1, Long op2, ObservableValue exp) {
780 assertEquals(op1 / op2, ((ObservableLongValue)exp).get());
781 }
782 },
783 longData
784 },
785 {
786 long1, long2,
787 new Functions<Long>() {
788 @Override
789 public Binding generateExpressionExpression(Object op1, Object op2) {
790 return Bindings.min((ObservableLongValue)op1, (ObservableLongValue)op2);
791 }
792 @Override
793 public Binding generateExpressionPrimitive(Object op1, Long op2) {
794 return Bindings.min((ObservableLongValue)op1, op2.longValue());
795 }
796 @Override
797 public Binding generatePrimitiveExpression(Long op1, Object op2) {
798 return Bindings.min(op1.longValue(), (ObservableLongValue)op2);
799 }
800 @Override
801 public void setOp1(Long value) {long1.set(value);}
802 @Override
803 public void setOp2(Long value) {long2.set(value);}
804 @Override
805 public void check(Long op1, Long op2, ObservableValue exp) {
806 assertEquals(Math.min(op1, op2), ((ObservableLongValue)exp).get());
807 }
808 },
809 longData
810 },
811 {
812 long1, long2,
813 new Functions<Long>() {
814 @Override
815 public Binding generateExpressionExpression(Object op1, Object op2) {
816 return Bindings.max((ObservableLongValue)op1, (ObservableLongValue)op2);
817 }
818 @Override
819 public Binding generateExpressionPrimitive(Object op1, Long op2) {
820 return Bindings.max((ObservableLongValue)op1, op2.longValue());
821 }
822 @Override
823 public Binding generatePrimitiveExpression(Long op1, Object op2) {
824 return Bindings.max(op1.longValue(), (ObservableLongValue)op2);
825 }
826 @Override
827 public void setOp1(Long value) {long1.set(value);}
828 @Override
829 public void setOp2(Long value) {long2.set(value);}
830 @Override
831 public void check(Long op1, Long op2, ObservableValue exp) {
832 assertEquals(Math.max(op1, op2), ((ObservableLongValue)exp).get());
833 }
834 },
835 longData
836 },
837 });
838 };
839 }