bundles/org.simantics.databoard/testcases/org/simantics/databoard/tests/TestBinding.java

   1 /*******************************************************************************
   2  *  Copyright (c) 2010 Association for Decentralized Information Management in
   3  *  Industry THTH ry.
   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
   8  *
   9  *  Contributors:
  10  *      VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.databoard.tests;
  13
  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;
  19
  20 import java.io.ByteArrayInputStream;
  21 import java.io.IOException;
  22 import java.io.InputStream;
  23 import java.util.Arrays;
  24
  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;
  39
  40 /**
  41  * This Test Case tests
  42  *  o ReflectionBinding, GeneralBinding
  43  *  o Boolean, Byte, Int, Long, Float, Double, String, Variant, Array, Map, Union, Record
  44  *  o Create, Read
  45  *  o Equals
  46  *  o HashCode
  47  *  o CompareTo (Binding & DataValueUtil)
  48  *  o Clone
  49  *  o Create Default
  50  *  o Adaption between bindings
  51  *  o Validator
  52  *  o Serializer
  53  *  o NullBinding Validator
  54  *  o Ascii Print/Parse
  55  *  o Recursion
  56  *
  57  * TODO Test Range & Length Annotations
  58  * TODO Test that map Sorts values
  59  * TODO Test Data Types
  60  *
  61  * @author Toni Kalajainen <toni.kalajainen@vtt.fi>
  62  */
  63 public class TestBinding extends TestData {
  64
  65         public static boolean OMIT_PARSER_TEST = true;
  66
  67         // boolean
  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);
  81         }
  82
  83         // byte
  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);
  97         }
  98
  99         // integer
 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);
 113         }
 114
 115         // long
 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);
 129         }
 130
 131         // float
 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);
 145         }
 146
 147         // double
 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);
 161         }
 162
 163         // string
 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);
 177         }
 178
 179         // array
 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);
 193         }
 194
 195         // boolean_array
 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);
 209         }
 210
 211         // byte_array
 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);
 225         }
 226
 227         // int_array
 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);
 241         }
 242
 243         // int_array_2d
 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);
 257         }
 258
 259         // long_array
 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);
 273         }
 274
 275         // float_array
 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);
 289         }
 290
 291         // double_array
 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);
 305         }
 306
 307         // string_array
 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);
 321         }
 322
 323         // record
 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);
 337         }
 338
 339         // map
 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);
 353
 354                 test_ordered_map_binding(map_binding_ref);
 355                 test_ordered_map_binding(map_binding_gen);
 356         }
 357
 358         // optional
 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);
 372         }
 373
 374         // union
 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);
 388         }
 389
 390         // variant
 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);
 404         }
 405
 406         // datatype
 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);
 411
 412                 RandomValue rv = new RandomValue();
 413                 rv.refereableRecords = true;
 414
 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);
 426                 }
 427
 428         }
 429
 430         // variant
 431         @Test public void test_random_values() throws Exception {
 432                 int iteration_count = 10000;
 433
 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();
 440
 441                         Object variant_value_gen_random_0 = variant_binding_gen.accept( rv );
 442
 443                         rv.getRandom().setSeed(seed);
 444                         rv.getRandom().nextLong();
 445                         Object variant_value_gen_random_1 = variant_binding_gen.accept( rv );
 446
 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);
 451                 }
 452         }
 453
 454         static void assert_same(Binding b1, Object o1, Binding b2, Object o2) throws BindingException, SerializationException, IOException, DataTypeSyntaxError, SerializerConstructionException
 455         {
 456                 // DataType Test
 457                 assertEquals( b1.type(), b2.type() );
 458                 Datatype t = b1.type();
 459
 460                 // CompareTo Test
 461                 assertEquals(0, Bindings.compare(b1, o1, b2, o2) );
 462
 463                 // Equals Test
 464                 assertTrue( Bindings.equals(b1, o1, b2, o2) );
 465
 466                 // HashCode Test
 467                 int hash1 = b1.hashValue(o1);
 468                 int hash2 = b2.hashValue(o2);
 469                 assertEquals( hash1, hash2 );
 470
 471                 // Validator Test
 472                 b1.assertInstaceIsValid(o1);
 473                 b2.assertInstaceIsValid(o2);
 474
 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) );
 482
 483                 // Clone Test
 484                 Object o1_ = Bindings.cloneUnchecked(o2, b2, b1);
 485                 Object o2_ = Bindings.cloneUnchecked(o1, b1, b2);
 486                 if (!b1.isImmutable() && !b2.isImmutable()) {
 487                         assertTrue(o1!=o1_);
 488                         assertTrue(o2!=o2_);
 489                 }
 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_);
 496
 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_);
 507
 508
 509                 // Adapter Test
 510                 o1_ = Bindings.adaptUnchecked(o2, b2, b1);
 511                 o2_ = Bindings.adaptUnchecked(o1, b1, b2);
 512
 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_);
 519
 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 );
 530
 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_) );
 535
 536                 b1.assertInstaceIsValid(o1_);
 537                 b2.assertInstaceIsValid(o2_);
 538
 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_);
 552
 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_);
 563                 }
 564
 565         }
 566
 567         static void assert_not_same(Binding b1, Object o1, Binding b2, Object o2) throws BindingException, SerializationException, IOException, DataTypeSyntaxError, SerializerConstructionException
 568         {
 569                 // DataType Test
 570                 assertEquals( b1.type(), b2.type() );
 571                 Datatype t = b1.type();
 572
 573                 // CompareTo Test
 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);
 577
 578                 // Equals Test
 579                 assertFalse( Bindings.equals(b1, o1, b2, o2) );
 580
 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 );
 585
 586                 // Validator Test
 587                 b1.assertInstaceIsValid(o1);
 588                 b2.assertInstaceIsValid(o2);
 589
 590                 // Adapter Test
 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_);
 600
 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_);
 619
 620
 621
 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_);
 639
 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_);
 655                 }
 656         }
 657
 658         static void assert_valid(Binding b, Object o) throws BindingException, IOException, SerializationException, DataTypeSyntaxError, SerializerConstructionException {
 659                 // Validator test
 660                 b.assertInstaceIsValid(o);
 661                 assertTrue( b.isInstance(o) );
 662
 663                 // Serializer test
 664                 Serializer s = Bindings.getSerializer( b );
 665                 byte[] bytes = s.serialize(o);
 666
 667                 InputStream is = new ByteArrayInputStream(bytes);
 668                 s.skip(is);
 669                 assertEquals(0, is.available());
 670
 671                 is = new ByteArrayInputStream(bytes);
 672                 s.deserialize(is);
 673                 assertEquals(0, is.available());
 674
 675                 Object o_ = s.deserialize( bytes );
 676                 assertEquals(0, b.compare(o, o_));
 677                 assertTrue( b.equals(o, o_) );
 678
 679                 // deserialize to instance Test
 680                 Binding gb = Bindings.getMutableBinding( b.type() );
 681                 o_ = gb.createDefault();
 682                 s = gb.serializer();
 683                 s.deserialize(bytes, o_);
 684                 assertTrue(Bindings.equals(b, o, gb, o_));
 685
 686                 // Read from test
 687                 o_ = gb.createDefault();
 688                 gb.readFrom(b, o, o_);
 689                 assertTrue(Bindings.equals(b, o, gb, o_));
 690
 691
 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_) );
 700                 }
 701         }
 702
 703         /**
 704          * This case tests ordered map features getFirst, getLast, getLower, getFloor, getHigher, getCeiling
 705          *
 706          * @param valueBinding Map(Integer, String)
 707          */
 708         void test_ordered_map_binding(MapBinding b) throws Exception {
 709
 710                 Datatype keyType = b.type().keyType;
 711                 Datatype valueType = b.type().valueType;
 712
 713                 assertTrue(keyType instanceof IntegerType);
 714                 assertTrue(valueType instanceof StringType);
 715
 716                 IntegerBinding kb = (IntegerBinding) b.getKeyBinding();
 717
 718                 Object map = b.createDefault();
 719                 Object value = "";
 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);
 727
 728                 assertEquals( b.getFirstKey(map), kb.create(0) );
 729                 assertEquals( b.getLastKey(map), kb.create(60) );
 730
 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);
 740
 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);
 750
 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);
 757
 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);
 764
 765
 766         }
 767
 768 }
 769