1 /*******************************************************************************
2 * Copyright (c) 2010 Association for Decentralized Information Management in
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * VTT Technical Research Centre of Finland - initial API and implementation
11 *******************************************************************************/
12 package org.simantics.databoard.tests;
14 import static org.junit.Assert.assertEquals;
15 import static org.junit.Assert.assertFalse;
16 import static org.junit.Assert.assertNotNull;
17 import static org.junit.Assert.assertNotSame;
18 import static org.junit.Assert.assertTrue;
20 import java.io.ByteArrayInputStream;
21 import java.io.IOException;
22 import java.io.InputStream;
23 import java.util.Arrays;
25 import org.junit.Test;
26 import org.simantics.databoard.Bindings;
27 import org.simantics.databoard.binding.Binding;
28 import org.simantics.databoard.binding.IntegerBinding;
29 import org.simantics.databoard.binding.MapBinding;
30 import org.simantics.databoard.binding.error.BindingException;
31 import org.simantics.databoard.binding.util.RandomValue;
32 import org.simantics.databoard.parser.repository.DataTypeSyntaxError;
33 import org.simantics.databoard.serialization.SerializationException;
34 import org.simantics.databoard.serialization.Serializer;
35 import org.simantics.databoard.serialization.SerializerConstructionException;
36 import org.simantics.databoard.type.Datatype;
37 import org.simantics.databoard.type.IntegerType;
38 import org.simantics.databoard.type.StringType;
41 * This Test Case tests
42 * o ReflectionBinding, GeneralBinding
43 * o Boolean, Byte, Int, Long, Float, Double, String, Variant, Array, Map, Union, Record
47 * o CompareTo (Binding & DataValueUtil)
50 * o Adaption between bindings
53 * o NullBinding Validator
57 * TODO Test Range & Length Annotations
58 * TODO Test that map Sorts values
59 * TODO Test Data Types
61 * @author Toni Kalajainen <toni.kalajainen@vtt.fi>
63 public class TestBinding extends TestData {
65 public static boolean OMIT_PARSER_TEST = true;
68 @Test public void test_boolean() throws Exception {
69 assert_same(boolean_binding_ref, boolean_value_ref_0, boolean_binding_gen, boolean_value_gen_0);
70 assert_same(boolean_binding_ref, boolean_value_ref_1, boolean_binding_gen, boolean_value_gen_1);
71 assert_same(boolean_binding_ref, boolean_value_ref_0, boolean_binding_ref, boolean_value_ref_0);
72 assert_same(boolean_binding_gen, boolean_value_gen_0, boolean_binding_gen, boolean_value_gen_0);
73 assert_not_same(boolean_binding_ref, boolean_value_ref_0, boolean_binding_gen, boolean_value_gen_1);
74 assert_not_same(boolean_binding_ref, boolean_value_ref_1, boolean_binding_gen, boolean_value_gen_0);
75 assert_not_same(boolean_binding_ref, boolean_value_ref_0, boolean_binding_ref, boolean_value_ref_1);
76 assert_not_same(boolean_binding_gen, boolean_value_gen_0, boolean_binding_gen, boolean_value_gen_1);
77 assert_valid(boolean_binding_ref, boolean_value_ref_0);
78 assert_valid(boolean_binding_ref, boolean_value_ref_1);
79 assert_valid(boolean_binding_gen, boolean_value_gen_0);
80 assert_valid(boolean_binding_gen, boolean_value_gen_1);
84 @Test public void test_byte() throws Exception {
85 assert_same(byte_binding_ref, byte_value_ref_0, byte_binding_gen, byte_value_gen_0);
86 assert_same(byte_binding_ref, byte_value_ref_1, byte_binding_gen, byte_value_gen_1);
87 assert_same(byte_binding_ref, byte_value_ref_0, byte_binding_ref, byte_value_ref_0);
88 assert_same(byte_binding_gen, byte_value_gen_0, byte_binding_gen, byte_value_gen_0);
89 assert_not_same(byte_binding_ref, byte_value_ref_0, byte_binding_gen, byte_value_gen_1);
90 assert_not_same(byte_binding_ref, byte_value_ref_1, byte_binding_gen, byte_value_gen_0);
91 assert_not_same(byte_binding_ref, byte_value_ref_0, byte_binding_ref, byte_value_ref_1);
92 assert_not_same(byte_binding_gen, byte_value_gen_0, byte_binding_gen, byte_value_gen_1);
93 assert_valid(byte_binding_ref, byte_value_ref_0);
94 assert_valid(byte_binding_ref, byte_value_ref_1);
95 assert_valid(byte_binding_gen, byte_value_gen_0);
96 assert_valid(byte_binding_gen, byte_value_gen_1);
100 @Test public void test_integer() throws Exception {
101 assert_same(integer_binding_ref, integer_value_ref_0, integer_binding_gen, integer_value_gen_0);
102 assert_same(integer_binding_ref, integer_value_ref_1, integer_binding_gen, integer_value_gen_1);
103 assert_same(integer_binding_ref, integer_value_ref_0, integer_binding_ref, integer_value_ref_0);
104 assert_same(integer_binding_gen, integer_value_gen_0, integer_binding_gen, integer_value_gen_0);
105 assert_not_same(integer_binding_ref, integer_value_ref_0, integer_binding_gen, integer_value_gen_1);
106 assert_not_same(integer_binding_ref, integer_value_ref_1, integer_binding_gen, integer_value_gen_0);
107 assert_not_same(integer_binding_ref, integer_value_ref_0, integer_binding_ref, integer_value_ref_1);
108 assert_not_same(integer_binding_gen, integer_value_gen_0, integer_binding_gen, integer_value_gen_1);
109 assert_valid(integer_binding_ref, integer_value_ref_0);
110 assert_valid(integer_binding_ref, integer_value_ref_1);
111 assert_valid(integer_binding_gen, integer_value_gen_0);
112 assert_valid(integer_binding_gen, integer_value_gen_1);
116 @Test public void test_long() throws Exception {
117 assert_same(long_binding_ref, long_value_ref_0, long_binding_gen, long_value_gen_0);
118 assert_same(long_binding_ref, long_value_ref_1, long_binding_gen, long_value_gen_1);
119 assert_same(long_binding_ref, long_value_ref_0, long_binding_ref, long_value_ref_0);
120 assert_same(long_binding_gen, long_value_gen_0, long_binding_gen, long_value_gen_0);
121 assert_not_same(long_binding_ref, long_value_ref_0, long_binding_gen, long_value_gen_1);
122 assert_not_same(long_binding_ref, long_value_ref_1, long_binding_gen, long_value_gen_0);
123 assert_not_same(long_binding_ref, long_value_ref_0, long_binding_ref, long_value_ref_1);
124 assert_not_same(long_binding_gen, long_value_gen_0, long_binding_gen, long_value_gen_1);
125 assert_valid(long_binding_ref, long_value_ref_0);
126 assert_valid(long_binding_ref, long_value_ref_1);
127 assert_valid(long_binding_gen, long_value_gen_0);
128 assert_valid(long_binding_gen, long_value_gen_1);
132 @Test public void test_float() throws Exception {
133 assert_same(float_binding_ref, float_value_ref_0, float_binding_gen, float_value_gen_0);
134 assert_same(float_binding_ref, float_value_ref_1, float_binding_gen, float_value_gen_1);
135 assert_same(float_binding_ref, float_value_ref_0, float_binding_ref, float_value_ref_0);
136 assert_same(float_binding_gen, float_value_gen_0, float_binding_gen, float_value_gen_0);
137 assert_not_same(float_binding_ref, float_value_ref_0, float_binding_gen, float_value_gen_1);
138 assert_not_same(float_binding_ref, float_value_ref_1, float_binding_gen, float_value_gen_0);
139 assert_not_same(float_binding_ref, float_value_ref_0, float_binding_ref, float_value_ref_1);
140 assert_not_same(float_binding_gen, float_value_gen_0, float_binding_gen, float_value_gen_1);
141 assert_valid(float_binding_ref, float_value_ref_0);
142 assert_valid(float_binding_ref, float_value_ref_1);
143 assert_valid(float_binding_gen, float_value_gen_0);
144 assert_valid(float_binding_gen, float_value_gen_1);
148 @Test public void test_double() throws Exception {
149 assert_same(double_binding_ref, double_value_ref_0, double_binding_gen, double_value_gen_0);
150 assert_same(double_binding_ref, double_value_ref_1, double_binding_gen, double_value_gen_1);
151 assert_same(double_binding_ref, double_value_ref_0, double_binding_ref, double_value_ref_0);
152 assert_same(double_binding_gen, double_value_gen_0, double_binding_gen, double_value_gen_0);
153 assert_not_same(double_binding_ref, double_value_ref_0, double_binding_gen, double_value_gen_1);
154 assert_not_same(double_binding_ref, double_value_ref_1, double_binding_gen, double_value_gen_0);
155 assert_not_same(double_binding_ref, double_value_ref_0, double_binding_ref, double_value_ref_1);
156 assert_not_same(double_binding_gen, double_value_gen_0, double_binding_gen, double_value_gen_1);
157 assert_valid(double_binding_ref, double_value_ref_0);
158 assert_valid(double_binding_ref, double_value_ref_1);
159 assert_valid(double_binding_gen, double_value_gen_0);
160 assert_valid(double_binding_gen, double_value_gen_1);
164 @Test public void test_string() throws Exception {
165 assert_same(string_binding_ref, string_value_ref_0, string_binding_gen, string_value_gen_0);
166 assert_same(string_binding_ref, string_value_ref_1, string_binding_gen, string_value_gen_1);
167 assert_same(string_binding_ref, string_value_ref_0, string_binding_ref, string_value_ref_0);
168 assert_same(string_binding_gen, string_value_gen_0, string_binding_gen, string_value_gen_0);
169 assert_not_same(string_binding_ref, string_value_ref_0, string_binding_gen, string_value_gen_1);
170 assert_not_same(string_binding_ref, string_value_ref_1, string_binding_gen, string_value_gen_0);
171 assert_not_same(string_binding_ref, string_value_ref_0, string_binding_ref, string_value_ref_1);
172 assert_not_same(string_binding_gen, string_value_gen_0, string_binding_gen, string_value_gen_1);
173 assert_valid(string_binding_ref, string_value_ref_0);
174 assert_valid(string_binding_ref, string_value_ref_1);
175 assert_valid(string_binding_gen, string_value_gen_0);
176 assert_valid(string_binding_gen, string_value_gen_1);
180 @Test public void test_array() throws Exception {
181 assert_same(array_binding_ref, array_value_ref_0, array_binding_gen, array_value_gen_0);
182 assert_same(array_binding_ref, array_value_ref_1, array_binding_gen, array_value_gen_1);
183 assert_same(array_binding_ref, array_value_ref_0, array_binding_ref, array_value_ref_0);
184 assert_same(array_binding_gen, array_value_gen_0, array_binding_gen, array_value_gen_0);
185 assert_not_same(array_binding_ref, array_value_ref_0, array_binding_gen, array_value_gen_1);
186 assert_not_same(array_binding_ref, array_value_ref_1, array_binding_gen, array_value_gen_0);
187 assert_not_same(array_binding_ref, array_value_ref_0, array_binding_ref, array_value_ref_1);
188 assert_not_same(array_binding_gen, array_value_gen_0, array_binding_gen, array_value_gen_1);
189 assert_valid(array_binding_ref, array_value_ref_0);
190 assert_valid(array_binding_ref, array_value_ref_1);
191 assert_valid(array_binding_gen, array_value_gen_0);
192 assert_valid(array_binding_gen, array_value_gen_1);
196 @Test public void test_boolean_array() throws Exception {
197 assert_same(boolean_array_binding_ref, boolean_array_value_ref_0, boolean_array_binding_gen, boolean_array_value_gen_0);
198 assert_same(boolean_array_binding_ref, boolean_array_value_ref_1, boolean_array_binding_gen, boolean_array_value_gen_1);
199 assert_same(boolean_array_binding_ref, boolean_array_value_ref_0, boolean_array_binding_ref, boolean_array_value_ref_0);
200 assert_same(boolean_array_binding_gen, boolean_array_value_gen_0, boolean_array_binding_gen, boolean_array_value_gen_0);
201 assert_not_same(boolean_array_binding_ref, boolean_array_value_ref_0, boolean_array_binding_gen, boolean_array_value_gen_1);
202 assert_not_same(boolean_array_binding_ref, boolean_array_value_ref_1, boolean_array_binding_gen, boolean_array_value_gen_0);
203 assert_not_same(boolean_array_binding_ref, boolean_array_value_ref_0, boolean_array_binding_ref, boolean_array_value_ref_1);
204 assert_not_same(boolean_array_binding_gen, boolean_array_value_gen_0, boolean_array_binding_gen, boolean_array_value_gen_1);
205 assert_valid(boolean_array_binding_ref, boolean_array_value_ref_0);
206 assert_valid(boolean_array_binding_ref, boolean_array_value_ref_1);
207 assert_valid(boolean_array_binding_gen, boolean_array_value_gen_0);
208 assert_valid(boolean_array_binding_gen, boolean_array_value_gen_1);
212 @Test public void test_byte_array() throws Exception {
213 assert_same(byte_array_binding_ref, byte_array_value_ref_0, byte_array_binding_gen, byte_array_value_gen_0);
214 assert_same(byte_array_binding_ref, byte_array_value_ref_1, byte_array_binding_gen, byte_array_value_gen_1);
215 assert_same(byte_array_binding_ref, byte_array_value_ref_0, byte_array_binding_ref, byte_array_value_ref_0);
216 assert_same(byte_array_binding_gen, byte_array_value_gen_0, byte_array_binding_gen, byte_array_value_gen_0);
217 assert_not_same(byte_array_binding_ref, byte_array_value_ref_0, byte_array_binding_gen, byte_array_value_gen_1);
218 assert_not_same(byte_array_binding_ref, byte_array_value_ref_1, byte_array_binding_gen, byte_array_value_gen_0);
219 assert_not_same(byte_array_binding_ref, byte_array_value_ref_0, byte_array_binding_ref, byte_array_value_ref_1);
220 assert_not_same(byte_array_binding_gen, byte_array_value_gen_0, byte_array_binding_gen, byte_array_value_gen_1);
221 assert_valid(byte_array_binding_ref, byte_array_value_ref_0);
222 assert_valid(byte_array_binding_ref, byte_array_value_ref_1);
223 assert_valid(byte_array_binding_gen, byte_array_value_gen_0);
224 assert_valid(byte_array_binding_gen, byte_array_value_gen_1);
228 @Test public void test_int_array() throws Exception {
229 assert_same(int_array_binding_ref, int_array_value_ref_0, int_array_binding_gen, int_array_value_gen_0);
230 assert_same(int_array_binding_ref, int_array_value_ref_1, int_array_binding_gen, int_array_value_gen_1);
231 assert_same(int_array_binding_ref, int_array_value_ref_0, int_array_binding_ref, int_array_value_ref_0);
232 assert_same(int_array_binding_gen, int_array_value_gen_0, int_array_binding_gen, int_array_value_gen_0);
233 assert_not_same(int_array_binding_ref, int_array_value_ref_0, int_array_binding_gen, int_array_value_gen_1);
234 assert_not_same(int_array_binding_ref, int_array_value_ref_1, int_array_binding_gen, int_array_value_gen_0);
235 assert_not_same(int_array_binding_ref, int_array_value_ref_0, int_array_binding_ref, int_array_value_ref_1);
236 assert_not_same(int_array_binding_gen, int_array_value_gen_0, int_array_binding_gen, int_array_value_gen_1);
237 assert_valid(int_array_binding_ref, int_array_value_ref_0);
238 assert_valid(int_array_binding_ref, int_array_value_ref_1);
239 assert_valid(int_array_binding_gen, int_array_value_gen_0);
240 assert_valid(int_array_binding_gen, int_array_value_gen_1);
244 @Test public void test_int_array_2d() throws Exception {
245 assert_same(int_array_2d_binding_ref, int_array_2d_value_ref_0, int_array_2d_binding_gen, int_array_2d_value_gen_0);
246 assert_same(int_array_2d_binding_ref, int_array_2d_value_ref_1, int_array_2d_binding_gen, int_array_2d_value_gen_1);
247 assert_same(int_array_2d_binding_ref, int_array_2d_value_ref_0, int_array_2d_binding_ref, int_array_2d_value_ref_0);
248 assert_same(int_array_2d_binding_gen, int_array_2d_value_gen_0, int_array_2d_binding_gen, int_array_2d_value_gen_0);
249 assert_not_same(int_array_2d_binding_ref, int_array_2d_value_ref_0, int_array_2d_binding_gen, int_array_2d_value_gen_1);
250 assert_not_same(int_array_2d_binding_ref, int_array_2d_value_ref_1, int_array_2d_binding_gen, int_array_2d_value_gen_0);
251 assert_not_same(int_array_2d_binding_ref, int_array_2d_value_ref_0, int_array_2d_binding_ref, int_array_2d_value_ref_1);
252 assert_not_same(int_array_2d_binding_gen, int_array_2d_value_gen_0, int_array_2d_binding_gen, int_array_2d_value_gen_1);
253 assert_valid(int_array_2d_binding_ref, int_array_2d_value_ref_0);
254 assert_valid(int_array_2d_binding_ref, int_array_2d_value_ref_1);
255 assert_valid(int_array_2d_binding_gen, int_array_2d_value_gen_0);
256 assert_valid(int_array_2d_binding_gen, int_array_2d_value_gen_1);
260 @Test public void test_long_array() throws Exception {
261 assert_same(long_array_binding_ref, long_array_value_ref_0, long_array_binding_gen, long_array_value_gen_0);
262 assert_same(long_array_binding_ref, long_array_value_ref_1, long_array_binding_gen, long_array_value_gen_1);
263 assert_same(long_array_binding_ref, long_array_value_ref_0, long_array_binding_ref, long_array_value_ref_0);
264 assert_same(long_array_binding_gen, long_array_value_gen_0, long_array_binding_gen, long_array_value_gen_0);
265 assert_not_same(long_array_binding_ref, long_array_value_ref_0, long_array_binding_gen, long_array_value_gen_1);
266 assert_not_same(long_array_binding_ref, long_array_value_ref_1, long_array_binding_gen, long_array_value_gen_0);
267 assert_not_same(long_array_binding_ref, long_array_value_ref_0, long_array_binding_ref, long_array_value_ref_1);
268 assert_not_same(long_array_binding_gen, long_array_value_gen_0, long_array_binding_gen, long_array_value_gen_1);
269 assert_valid(long_array_binding_ref, long_array_value_ref_0);
270 assert_valid(long_array_binding_ref, long_array_value_ref_1);
271 assert_valid(long_array_binding_gen, long_array_value_gen_0);
272 assert_valid(long_array_binding_gen, long_array_value_gen_1);
276 @Test public void test_float_array() throws Exception {
277 assert_same(float_array_binding_ref, float_array_value_ref_0, float_array_binding_gen, float_array_value_gen_0);
278 assert_same(float_array_binding_ref, float_array_value_ref_1, float_array_binding_gen, float_array_value_gen_1);
279 assert_same(float_array_binding_ref, float_array_value_ref_0, float_array_binding_ref, float_array_value_ref_0);
280 assert_same(float_array_binding_gen, float_array_value_gen_0, float_array_binding_gen, float_array_value_gen_0);
281 assert_not_same(float_array_binding_ref, float_array_value_ref_0, float_array_binding_gen, float_array_value_gen_1);
282 assert_not_same(float_array_binding_ref, float_array_value_ref_1, float_array_binding_gen, float_array_value_gen_0);
283 assert_not_same(float_array_binding_ref, float_array_value_ref_0, float_array_binding_ref, float_array_value_ref_1);
284 assert_not_same(float_array_binding_gen, float_array_value_gen_0, float_array_binding_gen, float_array_value_gen_1);
285 assert_valid(float_array_binding_ref, float_array_value_ref_0);
286 assert_valid(float_array_binding_ref, float_array_value_ref_1);
287 assert_valid(float_array_binding_gen, float_array_value_gen_0);
288 assert_valid(float_array_binding_gen, float_array_value_gen_1);
292 @Test public void test_double_array() throws Exception {
293 assert_same(double_array_binding_ref, double_array_value_ref_0, double_array_binding_gen, double_array_value_gen_0);
294 assert_same(double_array_binding_ref, double_array_value_ref_1, double_array_binding_gen, double_array_value_gen_1);
295 assert_same(double_array_binding_ref, double_array_value_ref_0, double_array_binding_ref, double_array_value_ref_0);
296 assert_same(double_array_binding_gen, double_array_value_gen_0, double_array_binding_gen, double_array_value_gen_0);
297 assert_not_same(double_array_binding_ref, double_array_value_ref_0, double_array_binding_gen, double_array_value_gen_1);
298 assert_not_same(double_array_binding_ref, double_array_value_ref_1, double_array_binding_gen, double_array_value_gen_0);
299 assert_not_same(double_array_binding_ref, double_array_value_ref_0, double_array_binding_ref, double_array_value_ref_1);
300 assert_not_same(double_array_binding_gen, double_array_value_gen_0, double_array_binding_gen, double_array_value_gen_1);
301 assert_valid(double_array_binding_ref, double_array_value_ref_0);
302 assert_valid(double_array_binding_ref, double_array_value_ref_1);
303 assert_valid(double_array_binding_gen, double_array_value_gen_0);
304 assert_valid(double_array_binding_gen, double_array_value_gen_1);
308 @Test public void test_string_array() throws Exception {
309 assert_same(string_array_binding_ref, string_array_value_ref_0, string_array_binding_gen, string_array_value_gen_0);
310 assert_same(string_array_binding_ref, string_array_value_ref_1, string_array_binding_gen, string_array_value_gen_1);
311 assert_same(string_array_binding_ref, string_array_value_ref_0, string_array_binding_ref, string_array_value_ref_0);
312 assert_same(string_array_binding_gen, string_array_value_gen_0, string_array_binding_gen, string_array_value_gen_0);
313 assert_not_same(string_array_binding_ref, string_array_value_ref_0, string_array_binding_gen, string_array_value_gen_1);
314 assert_not_same(string_array_binding_ref, string_array_value_ref_1, string_array_binding_gen, string_array_value_gen_0);
315 assert_not_same(string_array_binding_ref, string_array_value_ref_0, string_array_binding_ref, string_array_value_ref_1);
316 assert_not_same(string_array_binding_gen, string_array_value_gen_0, string_array_binding_gen, string_array_value_gen_1);
317 assert_valid(string_array_binding_ref, string_array_value_ref_0);
318 assert_valid(string_array_binding_ref, string_array_value_ref_1);
319 assert_valid(string_array_binding_gen, string_array_value_gen_0);
320 assert_valid(string_array_binding_gen, string_array_value_gen_1);
324 @Test public void test_record() throws Exception {
325 assert_same(record_binding_ref, record_value_ref_0, record_binding_gen, record_value_gen_0);
326 assert_same(record_binding_ref, record_value_ref_1, record_binding_gen, record_value_gen_1);
327 assert_same(record_binding_ref, record_value_ref_0, record_binding_ref, record_value_ref_0);
328 assert_same(record_binding_gen, record_value_gen_0, record_binding_gen, record_value_gen_0);
329 assert_not_same(record_binding_ref, record_value_ref_0, record_binding_gen, record_value_gen_1);
330 assert_not_same(record_binding_ref, record_value_ref_1, record_binding_gen, record_value_gen_0);
331 assert_not_same(record_binding_ref, record_value_ref_0, record_binding_ref, record_value_ref_1);
332 assert_not_same(record_binding_gen, record_value_gen_0, record_binding_gen, record_value_gen_1);
333 assert_valid(record_binding_ref, record_value_ref_0);
334 assert_valid(record_binding_ref, record_value_ref_1);
335 assert_valid(record_binding_gen, record_value_gen_0);
336 assert_valid(record_binding_gen, record_value_gen_1);
340 @Test public void test_map() throws Exception {
341 assert_same(map_binding_ref, map_value_ref_0, map_binding_gen, map_value_gen_0);
342 assert_same(map_binding_ref, map_value_ref_1, map_binding_gen, map_value_gen_1);
343 assert_same(map_binding_ref, map_value_ref_0, map_binding_ref, map_value_ref_0);
344 assert_same(map_binding_gen, map_value_gen_0, map_binding_gen, map_value_gen_0);
345 assert_not_same(map_binding_ref, map_value_ref_0, map_binding_gen, map_value_gen_1);
346 assert_not_same(map_binding_ref, map_value_ref_1, map_binding_gen, map_value_gen_0);
347 assert_not_same(map_binding_ref, map_value_ref_0, map_binding_ref, map_value_ref_1);
348 assert_not_same(map_binding_gen, map_value_gen_0, map_binding_gen, map_value_gen_1);
349 assert_valid(map_binding_ref, map_value_ref_0);
350 assert_valid(map_binding_ref, map_value_ref_1);
351 assert_valid(map_binding_gen, map_value_gen_0);
352 assert_valid(map_binding_gen, map_value_gen_1);
354 test_ordered_map_binding(map_binding_ref);
355 test_ordered_map_binding(map_binding_gen);
359 @Test public void test_optional() throws Exception {
360 assert_same(optional_binding_ref, optional_value_ref_0, optional_binding_gen, optional_value_gen_0);
361 assert_same(optional_binding_ref, optional_value_ref_1, optional_binding_gen, optional_value_gen_1);
362 assert_same(optional_binding_ref, optional_value_ref_0, optional_binding_ref, optional_value_ref_0);
363 assert_same(optional_binding_gen, optional_value_gen_0, optional_binding_gen, optional_value_gen_0);
364 assert_not_same(optional_binding_ref, optional_value_ref_0, optional_binding_gen, optional_value_gen_1);
365 assert_not_same(optional_binding_ref, optional_value_ref_1, optional_binding_gen, optional_value_gen_0);
366 assert_not_same(optional_binding_ref, optional_value_ref_0, optional_binding_ref, optional_value_ref_1);
367 assert_not_same(optional_binding_gen, optional_value_gen_0, optional_binding_gen, optional_value_gen_1);
368 assert_valid(optional_binding_ref, optional_value_ref_0);
369 assert_valid(optional_binding_ref, optional_value_ref_1);
370 assert_valid(optional_binding_gen, optional_value_gen_0);
371 assert_valid(optional_binding_gen, optional_value_gen_1);
375 @Test public void test_union() throws Exception {
376 assert_same(union_binding_ref, union_value_ref_0, union_binding_gen, union_value_gen_0);
377 assert_same(union_binding_ref, union_value_ref_1, union_binding_gen, union_value_gen_1);
378 assert_same(union_binding_ref, union_value_ref_0, union_binding_ref, union_value_ref_0);
379 assert_same(union_binding_gen, union_value_gen_0, union_binding_gen, union_value_gen_0);
380 assert_not_same(union_binding_ref, union_value_ref_0, union_binding_gen, union_value_gen_1);
381 assert_not_same(union_binding_ref, union_value_ref_1, union_binding_gen, union_value_gen_0);
382 assert_not_same(union_binding_ref, union_value_ref_0, union_binding_ref, union_value_ref_1);
383 assert_not_same(union_binding_gen, union_value_gen_0, union_binding_gen, union_value_gen_1);
384 assert_valid(union_binding_ref, union_value_ref_0);
385 assert_valid(union_binding_ref, union_value_ref_1);
386 assert_valid(union_binding_gen, union_value_gen_0);
387 assert_valid(union_binding_gen, union_value_gen_1);
391 @Test public void test_variant() throws Exception {
392 assert_same(variant_binding_ref, variant_value_ref_0, variant_binding_gen, variant_value_gen_0);
393 assert_same(variant_binding_ref, variant_value_ref_1, variant_binding_gen, variant_value_gen_1);
394 assert_same(variant_binding_ref, variant_value_ref_0, variant_binding_ref, variant_value_ref_0);
395 assert_same(variant_binding_gen, variant_value_gen_0, variant_binding_gen, variant_value_gen_0);
396 assert_not_same(variant_binding_ref, variant_value_ref_0, variant_binding_gen, variant_value_gen_1);
397 assert_not_same(variant_binding_ref, variant_value_ref_1, variant_binding_gen, variant_value_gen_0);
398 assert_not_same(variant_binding_ref, variant_value_ref_0, variant_binding_ref, variant_value_ref_1);
399 assert_not_same(variant_binding_gen, variant_value_gen_0, variant_binding_gen, variant_value_gen_1);
400 assert_valid(variant_binding_ref, variant_value_ref_0);
401 assert_valid(variant_binding_ref, variant_value_ref_1);
402 assert_valid(variant_binding_gen, variant_value_gen_0);
403 assert_valid(variant_binding_gen, variant_value_gen_1);
407 @Test public void test_datatype() throws Exception {
408 assert_same(datatype_binding_ref, datatype_value_ref_0, datatype_binding_ref, datatype_value_ref_0);
409 assert_not_same(datatype_binding_ref, datatype_value_ref_0, datatype_binding_ref, datatype_value_ref_1);
410 assert_valid(datatype_binding_ref, datatype_value_ref_1);
412 RandomValue rv = new RandomValue();
413 rv.refereableRecords = true;
415 int iteration_count = 100;
416 for (int iteration = 0; iteration < iteration_count; iteration++) {
417 int seed = iteration;
418 rv.getRandom().setSeed(seed);
419 rv.getRandom().nextLong();
420 Binding b = datatype_binding_ref;
421 Object rt = rv.randomType(0, 3);
422 Serializer s = b.serializer();
423 byte[] bytes = s.serialize( rt );
424 Object rt2 = s.deserialize( bytes );
425 b.assertInstaceIsValid(rt2);
431 @Test public void test_random_values() throws Exception {
432 int iteration_count = 10000;
434 RandomValue rv = new RandomValue();
435 rv.refereableRecords = true;
436 for (int iteration = 0; iteration < iteration_count; iteration++) {
437 int seed = iteration;
438 rv.getRandom().setSeed(seed);
439 rv.getRandom().nextLong();
441 Object variant_value_gen_random_0 = variant_binding_gen.accept( rv );
443 rv.getRandom().setSeed(seed);
444 rv.getRandom().nextLong();
445 Object variant_value_gen_random_1 = variant_binding_gen.accept( rv );
447 assert_same(variant_binding_gen, variant_value_gen_random_0, variant_binding_gen, variant_value_gen_random_0);
448 assert_same(variant_binding_gen, variant_value_gen_random_1, variant_binding_gen, variant_value_gen_random_1);
449 assert_valid(variant_binding_gen, variant_value_gen_random_0);
450 assert_valid(variant_binding_gen, variant_value_gen_random_1);
454 static void assert_same(Binding b1, Object o1, Binding b2, Object o2) throws BindingException, SerializationException, IOException, DataTypeSyntaxError, SerializerConstructionException
457 assertEquals( b1.type(), b2.type() );
458 Datatype t = b1.type();
461 assertEquals(0, Bindings.compare(b1, o1, b2, o2) );
464 assertTrue( Bindings.equals(b1, o1, b2, o2) );
467 int hash1 = b1.hashValue(o1);
468 int hash2 = b2.hashValue(o2);
469 assertEquals( hash1, hash2 );
472 b1.assertInstaceIsValid(o1);
473 b2.assertInstaceIsValid(o2);
475 // Default Value Test
476 Object x1 = b1.createDefault();
477 Object x2 = b2.createDefault();
478 b1.assertInstaceIsValid(x1);
479 b2.assertInstaceIsValid(x2);
480 assertEquals(0, Bindings.compare(b1, x1, b2, x2) );
481 assertTrue( Bindings.equals(b1, x1, b2, x2) );
484 Object o1_ = Bindings.cloneUnchecked(o2, b2, b1);
485 Object o2_ = Bindings.cloneUnchecked(o1, b1, b2);
486 if (!b1.isImmutable() && !b2.isImmutable()) {
490 assertEquals(0, b1.compare(o1, o1_));
491 assertEquals(0, b2.compare(o2, o2_));
492 assertTrue( b1.equals(o1, o1_) );
493 assertTrue( b2.equals(o2, o2_) );
494 b1.assertInstaceIsValid(o1_);
495 b2.assertInstaceIsValid(o2_);
497 o1_ = b1.cloneUnchecked(o1);
498 o2_ = b2.cloneUnchecked(o2);
499 if (!b1.isImmutable()) assertTrue(o1!=o1_);
500 if (!b2.isImmutable()) assertTrue(o2!=o2_);
501 assertEquals(0, b1.compare(o1, o1_));
502 assertEquals(0, b2.compare(o2, o2_));
503 assertTrue( b1.equals(o1, o1_) );
504 assertTrue( b2.equals(o2, o2_) );
505 b1.assertInstaceIsValid(o1_);
506 b2.assertInstaceIsValid(o2_);
510 o1_ = Bindings.adaptUnchecked(o2, b2, b1);
511 o2_ = Bindings.adaptUnchecked(o1, b1, b2);
513 assertEquals(0, b1.compare(o1, o1_));
514 assertEquals(0, b2.compare(o2, o2_));
515 assertTrue( b1.equals(o1, o1_) );
516 assertTrue( b2.equals(o2, o2_) );
517 b1.assertInstaceIsValid(o1_);
518 b2.assertInstaceIsValid(o2_);
520 // Binary Serializer Test
521 Serializer s1 = Bindings.getSerializer( b1 );
522 Serializer s2 = Bindings.getSerializer( b2 );
523 byte[] byte1 = s1.serialize(o1);
524 byte[] byte2 = s2.serialize(o2);
525 assertNotNull(byte1);
526 assertNotNull(byte2);
527 assertTrue( Arrays.equals(byte1, byte2) );
528 o1_ = s1.deserialize( byte2 );
529 o2_ = s2.deserialize( byte1 );
531 assertEquals(0, b1.compare(o1, o1_));
532 assertTrue( b1.equals(o1, o1_) );
533 assertEquals(0, b2.compare(o2, o2_));
534 assertTrue( b2.equals(o2, o2_) );
536 b1.assertInstaceIsValid(o1_);
537 b2.assertInstaceIsValid(o2_);
539 // Ascii Serializer Test
540 if (!OMIT_PARSER_TEST) {
541 String str1 = b1.printValueDefinition(o1, true);
542 String str2 = b2.printValueDefinition(o2, true);
543 assertEquals(str1, str2);
544 o1_ = b1.parseValueDefinition(str1);
545 o2_ = b2.parseValueDefinition(str2);
546 assertEquals(0, b1.compare(o1, o1_));
547 assertEquals(0, b2.compare(o2, o2_));
548 assertTrue( b1.equals(o1, o1_) );
549 assertTrue( b2.equals(o2, o2_) );
550 b1.assertInstaceIsValid(o1_);
551 b2.assertInstaceIsValid(o2_);
553 str1 = b1.printValueDefinition(o1, false);
554 str2 = b2.printValueDefinition(o2, false);
555 o1_ = b1.parseValueDefinition(str1);
556 o2_ = b2.parseValueDefinition(str2);
557 assertEquals(0, b1.compare(o1, o1_));
558 assertTrue( b1.equals(o1, o1_) );
559 assertEquals(0, b2.compare(o2, o2_));
560 assertTrue( b2.equals(o2, o2_) );
561 b1.assertInstaceIsValid(o1_);
562 b2.assertInstaceIsValid(o2_);
567 static void assert_not_same(Binding b1, Object o1, Binding b2, Object o2) throws BindingException, SerializationException, IOException, DataTypeSyntaxError, SerializerConstructionException
570 assertEquals( b1.type(), b2.type() );
571 Datatype t = b1.type();
574 int dif = Integer.signum( Bindings.compare(b1, o1, b2, o2) );
575 int dif2 = Integer.signum( Bindings.compare(b2, o2, b1, o1) );
576 assertEquals(-dif2, dif);
579 assertFalse( Bindings.equals(b1, o1, b2, o2) );
581 // HashCode Test (they could match by coincidence, we trust they don't)
582 int hash1 = b1.hashValue(o1);
583 int hash2 = b2.hashValue(o2);
584 assertNotSame( hash1, hash2 );
587 b1.assertInstaceIsValid(o1);
588 b2.assertInstaceIsValid(o2);
591 Object o1_ = Bindings.adaptUnchecked(o2, b2, b1);
592 Object o2_ = Bindings.adaptUnchecked(o1, b1, b2);
593 dif = Integer.signum( Bindings.compare(b1, o1_, b2, o2_) );
594 dif2 = Integer.signum( Bindings.compare(b2, o2_, b1, o1_) );
595 assertEquals(-dif2, dif);
596 assertFalse( b1.equals(o1, o1_) );
597 assertFalse( b2.equals(o2, o2_) );
598 b1.assertInstaceIsValid(o1_);
599 b2.assertInstaceIsValid(o2_);
601 // Binary Serializer Test
602 Serializer s1 = Bindings.getSerializer( b1 );
603 Serializer s2 = Bindings.getSerializer( b2 );
604 byte[] byte1 = s1.serialize(o1);
605 byte[] byte2 = s2.serialize(o2);
606 assertFalse( Arrays.equals(byte1, byte2) );
607 o1_ = s1.deserialize( byte2 );
608 o2_ = s2.deserialize( byte1 );
609 dif = Integer.signum( Bindings.compare(b1, o1_, b2, o2_) );
610 dif2 = Integer.signum( Bindings.compare(b2, o2_, b1, o1_) );
611 assertEquals(-dif2, dif);
612 dif = Integer.signum( Bindings.compare(b1, o1, b1, o1_) );
613 dif2 = Integer.signum( Bindings.compare(b2, o2, b2, o2_) );
614 assertEquals(-dif2, dif);
615 assertFalse( b1.equals(o1, o1_) );
616 assertFalse( b2.equals(o2, o2_) );
617 b1.assertInstaceIsValid(o1_);
618 b2.assertInstaceIsValid(o2_);
622 // Ascii Serializer Test
623 if (!OMIT_PARSER_TEST) {
624 String str1 = b1.printValueDefinition(o1, true);
625 String str2 = b2.printValueDefinition(o2, true);
626 assertNotSame(str1, str2);
627 o1_ = b1.parseValueDefinition(str2);
628 o2_ = b2.parseValueDefinition(str1);
629 dif = Integer.signum( Bindings.compare(b1, o1_, b2, o2_) );
630 dif2 = Integer.signum( Bindings.compare(b2, o2_, b1, o1_) );
631 assertEquals(-dif2, dif);
632 dif = Integer.signum( Bindings.compare(b1, o1, b1, o1_) );
633 dif2 = Integer.signum( Bindings.compare(b2, o2, b2, o2_) );
634 assertEquals(-dif2, dif);
635 assertFalse( b1.equals(o1, o1_) );
636 assertFalse( b2.equals(o2, o2_) );
637 b1.assertInstaceIsValid(o1_);
638 b2.assertInstaceIsValid(o2_);
640 str1 = b1.printValueDefinition(o1, false);
641 str2 = b2.printValueDefinition(o2, false);
642 assertNotSame(str1, str2);
643 o1_ = b1.parseValueDefinition(str2);
644 o2_ = b2.parseValueDefinition(str1);
645 dif = Integer.signum( Bindings.compare(b1, o1_, b2, o2_) );
646 dif2 = Integer.signum( Bindings.compare(b2, o2_, b1, o1_) );
647 assertEquals(-dif2, dif);
648 dif = Integer.signum( Bindings.compare(b1, o1, b1, o1_) );
649 dif2 = Integer.signum( Bindings.compare(b2, o2, b2, o2_) );
650 assertEquals(-dif2, dif);
651 assertFalse( b1.equals(o1, o1_) );
652 assertFalse( b2.equals(o2, o2_) );
653 b1.assertInstaceIsValid(o1_);
654 b2.assertInstaceIsValid(o2_);
658 static void assert_valid(Binding b, Object o) throws BindingException, IOException, SerializationException, DataTypeSyntaxError, SerializerConstructionException {
660 b.assertInstaceIsValid(o);
661 assertTrue( b.isInstance(o) );
664 Serializer s = Bindings.getSerializer( b );
665 byte[] bytes = s.serialize(o);
667 InputStream is = new ByteArrayInputStream(bytes);
669 assertEquals(0, is.available());
671 is = new ByteArrayInputStream(bytes);
673 assertEquals(0, is.available());
675 Object o_ = s.deserialize( bytes );
676 assertEquals(0, b.compare(o, o_));
677 assertTrue( b.equals(o, o_) );
679 // deserialize to instance Test
680 Binding gb = Bindings.getMutableBinding( b.type() );
681 o_ = gb.createDefault();
683 s.deserialize(bytes, o_);
684 assertTrue(Bindings.equals(b, o, gb, o_));
687 o_ = gb.createDefault();
688 gb.readFrom(b, o, o_);
689 assertTrue(Bindings.equals(b, o, gb, o_));
692 // Ascii Serializer Test
693 if (!OMIT_PARSER_TEST) {
694 String str = b.printValueDefinition(o, true);
695 o_ = b.parseValueDefinition(str);
696 assertEquals(0, b.compare(o, o_));
697 assertTrue( b.equals(o, o_) );
698 b.assertInstaceIsValid(o_);
699 assertTrue( b.isInstance(o_) );
704 * This case tests ordered map features getFirst, getLast, getLower, getFloor, getHigher, getCeiling
706 * @param valueBinding Map(Integer, String)
708 void test_ordered_map_binding(MapBinding b) throws Exception {
710 Datatype keyType = b.type().keyType;
711 Datatype valueType = b.type().valueType;
713 assertTrue(keyType instanceof IntegerType);
714 assertTrue(valueType instanceof StringType);
716 IntegerBinding kb = (IntegerBinding) b.getKeyBinding();
718 Object map = b.createDefault();
720 b.put(map, kb.create(0), value);
721 b.put(map, kb.create(50), value);
722 b.put(map, kb.create(10), value);
723 b.put(map, kb.create(30), value);
724 b.put(map, kb.create(40), value);
725 b.put(map, kb.create(60), value);
726 b.put(map, kb.create(20), value);
728 assertEquals( b.getFirstKey(map), kb.create(0) );
729 assertEquals( b.getLastKey(map), kb.create(60) );
731 assertEquals( b.getFloorKey(map, kb.create(30)), kb.create(30));
732 assertEquals( b.getFloorKey(map, kb.create(29)), kb.create(20));
733 assertEquals( b.getFloorKey(map, kb.create(31)), kb.create(30));
734 assertEquals( b.getFloorKey(map, kb.create(70)), kb.create(60));
735 assertEquals( b.getFloorKey(map, kb.create(60)), kb.create(60));
736 assertEquals( b.getFloorKey(map, kb.create(61)), kb.create(60));
737 assertEquals( b.getFloorKey(map, kb.create(1)), kb.create(0));
738 assertEquals( b.getFloorKey(map, kb.create(0)), kb.create(0));
739 assertEquals( b.getFloorKey(map, kb.create(-1)), null);
741 assertEquals( b.getLowerKey(map, kb.create(30)), kb.create(20));
742 assertEquals( b.getLowerKey(map, kb.create(29)), kb.create(20));
743 assertEquals( b.getLowerKey(map, kb.create(31)), kb.create(30));
744 assertEquals( b.getLowerKey(map, kb.create(70)), kb.create(60));
745 assertEquals( b.getLowerKey(map, kb.create(60)), kb.create(50));
746 assertEquals( b.getLowerKey(map, kb.create(61)), kb.create(60));
747 assertEquals( b.getLowerKey(map, kb.create(1)), kb.create(0));
748 assertEquals( b.getLowerKey(map, kb.create(0)), null);
749 assertEquals( b.getLowerKey(map, kb.create(-1)), null);
751 assertEquals( b.getCeilingKey(map, kb.create(30)), kb.create(30));
752 assertEquals( b.getCeilingKey(map, kb.create(29)), kb.create(30));
753 assertEquals( b.getCeilingKey(map, kb.create(31)), kb.create(40));
754 assertEquals( b.getCeilingKey(map, kb.create(-10)), kb.create(0));
755 assertEquals( b.getCeilingKey(map, kb.create(60)), kb.create(60));
756 assertEquals( b.getCeilingKey(map, kb.create(61)), null);
758 assertEquals( b.getHigherKey(map, kb.create(30)), kb.create(40));
759 assertEquals( b.getHigherKey(map, kb.create(29)), kb.create(30));
760 assertEquals( b.getHigherKey(map, kb.create(31)), kb.create(40));
761 assertEquals( b.getHigherKey(map, kb.create(-10)), kb.create(0));
762 assertEquals( b.getHigherKey(map, kb.create(60)), null);
763 assertEquals( b.getHigherKey(map, kb.create(61)), null);