review.fuel-infra Code Review - packages/trusty/mysql-wsrep-5.6.git/blob

   1 /*
   2    Copyright 2010 Sun Microsystems, Inc.
   3    All rights reserved. Use is subject to license terms.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; version 2 of the License.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
  17 */
  18
  19 package testsuite.clusterj;
  20
  21 import com.mysql.clusterj.ClusterJDatastoreException;
  22 import com.mysql.clusterj.ClusterJUserException;
  23 import testsuite.clusterj.model.NullValues;
  24
  25 public class NullValuesTest extends AbstractClusterJModelTest {
  26
  27     protected static final String tablename = "nullvalues";
  28     protected static final int numberOfPropertyTypes = 7;
  29     protected static final int numberOfFieldsPerProperty = 12;
  30
  31     /** The sum of the following values is the switch index into the
  32      * field setting method.
  33      */
  34     protected static final int DATABASE_NOT_NULL = 0; //  if the column is defined as not nullable
  35     protected static final int DATABASE_NULL =  1; // if the column is defined as nullable
  36     protected static final String[] databaseNull =
  37             new String[] {"DATABASE_NOT_NULL", "DATABASE_NULL"};
  38     protected static final int DATABASE_NO_DEFAULT = 0; // if the column has no default value in the database schema
  39     protected static final int DATABASE_DEFAULT = 2; // if the column has a default value in the database schema
  40     protected static final String[] databaseDefault =
  41             new String[] {"DATABASE_NO_DEFAULT", "DATABASE_DEFAULT"};
  42     protected static final int NULLVALUE_NONE = 0; // if the property is NullValue.NONE
  43     protected static final int NULLVALUE_EXCEPTION = 4; // if the property is NullValue.EXCEPTION
  44     protected static final int NULLVALUE_DEFAULT = 8; // if the property is NullValue.DEFAULT
  45     protected static final String[] nullValue =
  46             new String[] {"NULL_VALUE_NONE", "NULL_VALUE_EXCEPTION", "NULL_VALUE_DEFAULT"};
  47
  48     protected static final String[] propertyTypes = new String[] {
  49         "Integer", "Long", "Short", "Byte", "String", "Float", "Double"};
  50
  51     @Override
  52     public void localSetUp() {
  53         createSessionFactory();
  54         session = sessionFactory.getSession();
  55         session.deletePersistentAll(NullValues.class);
  56         addTearDownClasses(NullValues.class);
  57     }
  58
  59     /** Test that the behavior of the NullValue annotation is effective.
  60      * For each column type, test the NullValue annotation behavior for
  61      * null values:
  62      * NullValue.NONE: nothing is done by ClusterJ, so the behavior of the
  63      * database takes over, which might result in an exception
  64      * or a default value being written
  65      * NullValue.EXCEPTION: ClusterJ throws an exception
  66      * NullValue.DEFAULT: ClusterJ sets the value to the default value as
  67      * defined in ClusterJ metadata
  68      * The test makes use of a class, NullValues, that contains properties
  69      * of all nullable types and all NullValue annotations on those types.
  70      * Each property is assigned a number for the test.
  71      *
  72      */
  73     public void test() {
  74
  75         tx = session.currentTransaction();
  76         // make sure we can commit a legal instance.
  77         if (true) {
  78             tx.begin();
  79             NullValues instance = createValidInstance();
  80             int id = 0;
  81             instance.setId(id);
  82             session.makePersistent(instance);
  83             tx.commit();
  84             tx.begin();
  85             instance = session.find(NullValues.class, id);
  86             session.deletePersistent(instance);
  87             tx.commit();
  88         }
  89         // iterate all property and field types and set the value of the
  90         // field to null and then commit.
  91         for (int propertyType = 0; propertyType < numberOfPropertyTypes; ++propertyType) {
  92             for (int fieldIndex = 0; fieldIndex < numberOfFieldsPerProperty; ++fieldIndex) {
  93                 NullValues instance = createValidInstance();
  94                 int id = propertyType * numberOfFieldsPerProperty + fieldIndex;
  95                 //System.out.println("id: " + id);
  96                 instance.setId(id);
  97                 try {
  98                     tx.begin();
  99                     // set one property to null value
 100                     setValue(instance, propertyType, fieldIndex, true);
 101                     // and see what happens
 102                     session.makePersistent(instance);
 103                     tx.commit();
 104                     //System.out.println("no exception for: " + id + " " + decodeValues(id));
 105                     if (expectedException(id, null)) {
 106                         error("Expected exception not thrown for case " +
 107                                 decodeType(propertyType) + ": " + decodeValues(id));
 108                     }
 109                 } catch (Exception e) {
 110                     // see if this is an expected exception
 111                     //System.out.println("exception for: " + id + " " + decodeValues(id));
 112                     if (!expectedException(id, e)) {
 113                         error("Unexpected exception from commit for case " +
 114                                 decodeType(propertyType) + ": "  + decodeValues(id)
 115                                 + " " + e.toString());
 116                         e.printStackTrace();
 117                     }
 118                     continue; // if an exception was caught, don't try to verify the instance
 119                 } finally {
 120                     if (tx.isActive()) {
 121                         tx.rollback();
 122                     }
 123                 }
 124                 try {
 125                     tx.begin();
 126                     instance = session.find(NullValues.class, id);
 127                     verifyNullValues(propertyType, fieldIndex, id, instance);
 128                     tx.commit();
 129                 } catch (Exception e) {
 130                     error("Unexpected exception from find for case" +
 131                             decodeType(propertyType) + ": "  + decodeValues(id)
 132                             + " " + e.toString());
 133                         e.printStackTrace();
 134                 }
 135             }
 136         }
 137         failOnError();
 138     }
 139
 140     protected NullValues createValidInstance() {
 141         NullValues instance = session.newInstance(NullValues.class);
 142         for (int propertyType = 0; propertyType < numberOfPropertyTypes; ++propertyType) {
 143             for (int fieldIndex = 0; fieldIndex < numberOfFieldsPerProperty; ++fieldIndex) {
 144                 // set all properties to non-null values
 145                 setValue(instance, propertyType, fieldIndex, false);
 146             }
 147         }
 148         return instance;
 149     }
 150
 151     protected int whatDatabaseDefault(int id) {
 152         return ((id % numberOfFieldsPerProperty) & 2) >> 1;
 153     }
 154
 155     protected int whatDatabaseNull(int id) {
 156         return (id % numberOfFieldsPerProperty) & 1;
 157     }
 158
 159     protected int whatNullValue(int id) {
 160         return ((id % numberOfFieldsPerProperty) & 12) >> 2;
 161     }
 162
 163     private String decodeValues(int id) {
 164 //    protected static final int DATABASE_NOT_NULL = 0; //  if the column is defined as not nullable
 165 //    protected static final int DATABASE_NULL =  1; // if the column is defined as nullable
 166         String databaseNullResult = databaseNull[whatDatabaseNull(id)];
 167 //    protected static final int DATABASE_NO_DEFAULT = 0; // if the column has no default value in the database schema
 168 //    protected static final int DATABASE_DEFAULT = 2; // if the column has a default value in the database schema
 169         String databaseDefaultResult = databaseDefault[whatDatabaseDefault(id)];
 170 //    protected static final int NULLVALUE_NONE = 0; // if the property is NullValue.NONE
 171 //    protected static final int NULLVALUE_EXCEPTION = 4; // if the property is NullValue.EXCEPTION
 172 //    protected static final int NULLVALUE_DEFAULT = 8; // if the property is NullValue.DEFAULT
 173         String nullValueResult = nullValue[whatNullValue(id)];
 174         return databaseNullResult + " " +
 175                 databaseDefaultResult + " " +
 176                 nullValueResult;
 177     }
 178
 179     private String decodeType(int type) {
 180         return propertyTypes[type];
 181     }
 182
 183     private boolean expectedException(int id, Exception e) {
 184         // if DATABASE_NOT_NULL and NULL_VALUE_NONE => ClusterJDatastoreException
 185         // the database exception might have been wrapped
 186         Throwable t = e==null?null:e.getCause();
 187         if (whatDatabaseNull(id) == 0 &&
 188                 (whatNullValue(id) == 0)) {
 189             if (e != null &&
 190                     e instanceof ClusterJDatastoreException) {
 191                 return true;
 192             } else if (t instanceof Exception) {
 193                     return expectedException(id, (Exception)t);
 194             } else {
 195                 return false;
 196             }
 197         }
 198         // if NULL_VALUE_EXCEPTION => ClusterJUserException
 199         if (whatNullValue(id) == 1) {
 200             if (e != null &&
 201                     e instanceof ClusterJUserException) {
 202                 return true;
 203             } else {
 204                 return false;
 205             }
 206         }
 207         // else no exception is expected
 208         return false;
 209     }
 210
 211     private void verifyNullValues(int propertyType, int fieldIndex, int id, NullValues instance) {
 212         Object value = getValue(instance, propertyType, fieldIndex);
 213         if (whatDatabaseNull(id) == DATABASE_NULL
 214                 && (whatDatabaseDefault(id) == DATABASE_NO_DEFAULT)
 215                 && (whatNullValue(id) == NULLVALUE_NONE)
 216                 ) {
 217             // should store a null in the database for this case
 218             errorIfNotEqual("For id " + id + " propertyType " + propertyType + " fieldIndex " + fieldIndex + " instance was " + (instance==null?"null":instance.toString() + " value was " + ((value==null)?"null ":value + " of type " + value.getClass().getName() + " " ) + decodeValues(id)), null, value);
 219         }
 220     }
 221
 222     /** Set the value of a specific field to either a null or not-null value.
 223      *
 224      * @param instance the instance to set values for
 225      * @param propertyType the property type
 226      * @param fieldIndex the field within the property
 227      * @param nullValue set to a null value
 228      */
 229     private void setValue(NullValues instance, int propertyType, int fieldIndex, boolean nullValue) {
 230         switch(propertyType) {
 231             case 0: // Integer
 232                 switch(fieldIndex) {
 233                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 234                         instance.setIntNotNullNoDefaultNullValueNone(nullValue?null:0); break;
 235                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 236                         instance.setIntNullNoDefaultNullValueNone(nullValue?null:0); break;
 237                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 238                         instance.setIntNotNullDefaultNullValueNone(nullValue?null:0); break;
 239                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 240                         instance.setIntNullDefaultNullValueNone(nullValue?null:0); break;
 241                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 242                         instance.setIntNotNullNoDefaultNullValueException(nullValue?null:0); break;
 243                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 244                         instance.setIntNullNoDefaultNullValueException(nullValue?null:0); break;
 245                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 246                         instance.setIntNotNullDefaultNullValueException(nullValue?null:0); break;
 247                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 248                         instance.setIntNullDefaultNullValueException(nullValue?null:0); break;
 249                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 250                         instance.setIntNotNullNoDefaultNullValueDefault(nullValue?null:0); break;
 251                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 252                         instance.setIntNullNoDefaultNullValueDefault(nullValue?null:0); break;
 253                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 254                         instance.setIntNotNullDefaultNullValueDefault(nullValue?null:0); break;
 255                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 256                         instance.setIntNullDefaultNullValueDefault(nullValue?null:0); break;
 257                     default:
 258                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 259                 }
 260                 break;
 261             case 1: // Long
 262                 switch(fieldIndex) {
 263                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 264                         instance.setLongNotNullNoDefaultNullValueNone(nullValue?null:0L); break;
 265                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 266                         instance.setLongNullNoDefaultNullValueNone(nullValue?null:0L); break;
 267                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 268                         instance.setLongNotNullDefaultNullValueNone(nullValue?null:0L); break;
 269                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 270                         instance.setLongNullDefaultNullValueNone(nullValue?null:0L); break;
 271                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 272                         instance.setLongNotNullNoDefaultNullValueException(nullValue?null:0L); break;
 273                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 274                         instance.setLongNullNoDefaultNullValueException(nullValue?null:0L); break;
 275                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 276                         instance.setLongNotNullDefaultNullValueException(nullValue?null:0L); break;
 277                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 278                         instance.setLongNullDefaultNullValueException(nullValue?null:0L); break;
 279                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 280                         instance.setLongNotNullNoDefaultNullValueDefault(nullValue?null:0L); break;
 281                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 282                         instance.setLongNullNoDefaultNullValueDefault(nullValue?null:0L); break;
 283                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 284                         instance.setLongNotNullDefaultNullValueDefault(nullValue?null:0L); break;
 285                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 286                         instance.setLongNullDefaultNullValueDefault(nullValue?null:0L); break;
 287                     default:
 288                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 289                 }
 290             case 2: // Short
 291                 switch(fieldIndex) {
 292                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 293                         instance.setShortNotNullNoDefaultNullValueNone(nullValue?null:(short)0); break;
 294                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 295                         instance.setShortNullNoDefaultNullValueNone(nullValue?null:(short)0); break;
 296                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 297                         instance.setShortNotNullDefaultNullValueNone(nullValue?null:(short)0); break;
 298                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 299                         instance.setShortNullDefaultNullValueNone(nullValue?null:(short)0); break;
 300                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 301                         instance.setShortNotNullNoDefaultNullValueException(nullValue?null:(short)0); break;
 302                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 303                         instance.setShortNullNoDefaultNullValueException(nullValue?null:(short)0); break;
 304                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 305                         instance.setShortNotNullDefaultNullValueException(nullValue?null:(short)0); break;
 306                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 307                         instance.setShortNullDefaultNullValueException(nullValue?null:(short)0); break;
 308                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 309                         instance.setShortNotNullNoDefaultNullValueDefault(nullValue?null:(short)0); break;
 310                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 311                         instance.setShortNullNoDefaultNullValueDefault(nullValue?null:(short)0); break;
 312                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 313                         instance.setShortNotNullDefaultNullValueDefault(nullValue?null:(short)0); break;
 314                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 315                         instance.setShortNullDefaultNullValueDefault(nullValue?null:(short)0); break;
 316                     default:
 317                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 318                 }
 319             case 3: // Byte
 320                 switch(fieldIndex) {
 321                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 322                         instance.setByteNotNullNoDefaultNullValueNone(nullValue?null:(byte)0); break;
 323                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 324                         instance.setByteNullNoDefaultNullValueNone(nullValue?null:(byte)0); break;
 325                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 326                         instance.setByteNotNullDefaultNullValueNone(nullValue?null:(byte)0); break;
 327                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 328                         instance.setByteNullDefaultNullValueNone(nullValue?null:(byte)0); break;
 329                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 330                         instance.setByteNotNullNoDefaultNullValueException(nullValue?null:(byte)0); break;
 331                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 332                         instance.setByteNullNoDefaultNullValueException(nullValue?null:(byte)0); break;
 333                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 334                         instance.setByteNotNullDefaultNullValueException(nullValue?null:(byte)0); break;
 335                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 336                         instance.setByteNullDefaultNullValueException(nullValue?null:(byte)0); break;
 337                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 338                         instance.setByteNotNullNoDefaultNullValueDefault(nullValue?null:(byte)0); break;
 339                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 340                         instance.setByteNullNoDefaultNullValueDefault(nullValue?null:(byte)0); break;
 341                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 342                         instance.setByteNotNullDefaultNullValueDefault(nullValue?null:(byte)0); break;
 343                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 344                         instance.setByteNullDefaultNullValueDefault(nullValue?null:(byte)0); break;
 345                     default:
 346                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 347                 }
 348             case 4: // String
 349                 switch(fieldIndex) {
 350                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 351                         instance.setStringNotNullNoDefaultNullValueNone(nullValue?null:"0"); break;
 352                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 353                         instance.setStringNullNoDefaultNullValueNone(nullValue?null:"0"); break;
 354                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 355                         instance.setStringNotNullDefaultNullValueNone(nullValue?null:"0"); break;
 356                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 357                         instance.setStringNullDefaultNullValueNone(nullValue?null:"0"); break;
 358                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 359                         instance.setStringNotNullNoDefaultNullValueException(nullValue?null:"0"); break;
 360                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 361                         instance.setStringNullNoDefaultNullValueException(nullValue?null:"0"); break;
 362                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 363                         instance.setStringNotNullDefaultNullValueException(nullValue?null:"0"); break;
 364                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 365                         instance.setStringNullDefaultNullValueException(nullValue?null:"0"); break;
 366                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 367                         instance.setStringNotNullNoDefaultNullValueDefault(nullValue?null:"0"); break;
 368                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 369                         instance.setStringNullNoDefaultNullValueDefault(nullValue?null:"0"); break;
 370                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 371                         instance.setStringNotNullDefaultNullValueDefault(nullValue?null:"0"); break;
 372                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 373                         instance.setStringNullDefaultNullValueDefault(nullValue?null:"0"); break;
 374                     default:
 375                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 376                 }
 377                 break;
 378             case 5: // Float
 379                 switch(fieldIndex) {
 380                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 381                         instance.setFloatNotNullNoDefaultNullValueNone(nullValue?null:0.0F); break;
 382                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 383                         instance.setFloatNullNoDefaultNullValueNone(nullValue?null:0.0F); break;
 384                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 385                         instance.setFloatNotNullDefaultNullValueNone(nullValue?null:0.0F); break;
 386                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 387                         instance.setFloatNullDefaultNullValueNone(nullValue?null:0.0F); break;
 388                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 389                         instance.setFloatNotNullNoDefaultNullValueException(nullValue?null:0.0F); break;
 390                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 391                         instance.setFloatNullNoDefaultNullValueException(nullValue?null:0.0F); break;
 392                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 393                         instance.setFloatNotNullDefaultNullValueException(nullValue?null:0.0F); break;
 394                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 395                         instance.setFloatNullDefaultNullValueException(nullValue?null:0.0F); break;
 396                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 397                         instance.setFloatNotNullNoDefaultNullValueDefault(nullValue?null:0.0F); break;
 398                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 399                         instance.setFloatNullNoDefaultNullValueDefault(nullValue?null:0.0F); break;
 400                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 401                         instance.setFloatNotNullDefaultNullValueDefault(nullValue?null:0.0F); break;
 402                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 403                         instance.setFloatNullDefaultNullValueDefault(nullValue?null:0.0F); break;
 404                     default:
 405                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 406                 }
 407                 break;
 408             case 6: // Double
 409                 switch(fieldIndex) {
 410                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 411                         instance.setDoubleNotNullNoDefaultNullValueNone(nullValue?null:0.0D); break;
 412                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 413                         instance.setDoubleNullNoDefaultNullValueNone(nullValue?null:0.0D); break;
 414                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 415                         instance.setDoubleNotNullDefaultNullValueNone(nullValue?null:0.0D); break;
 416                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 417                         instance.setDoubleNullDefaultNullValueNone(nullValue?null:0.0D); break;
 418                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 419                         instance.setDoubleNotNullNoDefaultNullValueException(nullValue?null:0.0D); break;
 420                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 421                         instance.setDoubleNullNoDefaultNullValueException(nullValue?null:0.0D); break;
 422                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 423                         instance.setDoubleNotNullDefaultNullValueException(nullValue?null:0.0D); break;
 424                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 425                         instance.setDoubleNullDefaultNullValueException(nullValue?null:0.0D); break;
 426                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 427                         instance.setDoubleNotNullNoDefaultNullValueDefault(nullValue?null:0.0D); break;
 428                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 429                         instance.setDoubleNullNoDefaultNullValueDefault(nullValue?null:0.0D); break;
 430                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 431                         instance.setDoubleNotNullDefaultNullValueDefault(nullValue?null:0.0D); break;
 432                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 433                         instance.setDoubleNullDefaultNullValueDefault(nullValue?null:0.0D); break;
 434                     default:
 435                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 436                 }
 437                 break;
 438             default:
 439                 throw new IllegalArgumentException("Illegal property type " + propertyType);
 440         }
 441     }
 442
 443     /** Get the value of a specific field.
 444      *
 445      * @param instance the instance to get values for
 446      * @param propertyType the property type
 447      * @param fieldIndex the field within the property
 448      */
 449     private Object getValue(NullValues instance, int propertyType, int fieldIndex) {
 450         if (instance == null)
 451             return null;
 452         switch(propertyType) {
 453             case 0: // Integer
 454                 switch(fieldIndex) {
 455                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 456                         return instance.getIntNotNullNoDefaultNullValueNone();
 457                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 458                         return instance.getIntNullNoDefaultNullValueNone();
 459                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 460                         return instance.getIntNotNullDefaultNullValueNone();
 461                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 462                         return instance.getIntNullDefaultNullValueNone();
 463                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 464                         return instance.getIntNotNullNoDefaultNullValueException();
 465                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 466                         return instance.getIntNullNoDefaultNullValueException();
 467                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 468                         return instance.getIntNotNullDefaultNullValueException();
 469                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 470                         return instance.getIntNullDefaultNullValueException();
 471                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 472                         return instance.getIntNotNullNoDefaultNullValueDefault();
 473                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 474                         return instance.getIntNullNoDefaultNullValueDefault();
 475                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 476                         return instance.getIntNotNullDefaultNullValueDefault();
 477                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 478                         return instance.getIntNullDefaultNullValueDefault();
 479                     default:
 480                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 481                 }
 482
 483             case 1: // Long
 484                 switch(fieldIndex) {
 485                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 486                         return instance.getLongNotNullNoDefaultNullValueNone();
 487                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 488                         return instance.getLongNullNoDefaultNullValueNone();
 489                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 490                         return instance.getLongNotNullDefaultNullValueNone();
 491                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 492                         return instance.getLongNullDefaultNullValueNone();
 493                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 494                         return instance.getLongNotNullNoDefaultNullValueException();
 495                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 496                         return instance.getLongNullNoDefaultNullValueException();
 497                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 498                         return instance.getLongNotNullDefaultNullValueException();
 499                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 500                         return instance.getLongNullDefaultNullValueException();
 501                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 502                         return instance.getLongNotNullNoDefaultNullValueDefault();
 503                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 504                         return instance.getLongNullNoDefaultNullValueDefault();
 505                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 506                         return instance.getLongNotNullDefaultNullValueDefault();
 507                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 508                         return instance.getLongNullDefaultNullValueDefault();
 509                     default:
 510                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 511                 }
 512             case 2: // Short
 513                 switch(fieldIndex) {
 514                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 515                         return instance.getShortNotNullNoDefaultNullValueNone();
 516                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 517                         return instance.getShortNullNoDefaultNullValueNone();
 518                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 519                         return instance.getShortNotNullDefaultNullValueNone();
 520                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 521                         return instance.getShortNullDefaultNullValueNone();
 522                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 523                         return instance.getShortNotNullNoDefaultNullValueException();
 524                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 525                         return instance.getShortNullNoDefaultNullValueException();
 526                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 527                         return instance.getShortNotNullDefaultNullValueException();
 528                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 529                         return instance.getShortNullDefaultNullValueException();
 530                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 531                         return instance.getShortNotNullNoDefaultNullValueDefault();
 532                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 533                         return instance.getShortNullNoDefaultNullValueDefault();
 534                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 535                         return instance.getShortNotNullDefaultNullValueDefault();
 536                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 537                         return instance.getShortNullDefaultNullValueDefault();
 538                     default:
 539                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 540                 }
 541             case 3: // Byte
 542                 switch(fieldIndex) {
 543                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 544                         return instance.getByteNotNullNoDefaultNullValueNone();
 545                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 546                         return instance.getByteNullNoDefaultNullValueNone();
 547                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 548                         return instance.getByteNotNullDefaultNullValueNone();
 549                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 550                         return instance.getByteNullDefaultNullValueNone();
 551                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 552                         return instance.getByteNotNullNoDefaultNullValueException();
 553                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 554                         return instance.getByteNullNoDefaultNullValueException();
 555                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 556                         return instance.getByteNotNullDefaultNullValueException();
 557                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 558                         return instance.getByteNullDefaultNullValueException();
 559                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 560                         return instance.getByteNotNullNoDefaultNullValueDefault();
 561                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 562                         return instance.getByteNullNoDefaultNullValueDefault();
 563                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 564                         return instance.getByteNotNullDefaultNullValueDefault();
 565                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 566                         return instance.getByteNullDefaultNullValueDefault();
 567                     default:
 568                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 569                 }
 570             case 4: // String
 571                 switch(fieldIndex) {
 572                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 573                         return instance.getStringNotNullNoDefaultNullValueNone();
 574                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 575                         return instance.getStringNullNoDefaultNullValueNone();
 576                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 577                         return instance.getStringNotNullDefaultNullValueNone();
 578                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 579                         return instance.getStringNullDefaultNullValueNone();
 580                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 581                         return instance.getStringNotNullNoDefaultNullValueException();
 582                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 583                         return instance.getStringNullNoDefaultNullValueException();
 584                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 585                         return instance.getStringNotNullDefaultNullValueException();
 586                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 587                         return instance.getStringNullDefaultNullValueException();
 588                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 589                         return instance.getStringNotNullNoDefaultNullValueDefault();
 590                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 591                         return instance.getStringNullNoDefaultNullValueDefault();
 592                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 593                         return instance.getStringNotNullDefaultNullValueDefault();
 594                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 595                         return instance.getStringNullDefaultNullValueDefault();
 596                     default:
 597                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 598                 }
 599
 600             case 5: // Float
 601                 switch(fieldIndex) {
 602                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 603                         return instance.getFloatNotNullNoDefaultNullValueNone();
 604                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 605                         return instance.getFloatNullNoDefaultNullValueNone();
 606                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 607                         return instance.getFloatNotNullDefaultNullValueNone();
 608                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 609                         return instance.getFloatNullDefaultNullValueNone();
 610                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 611                         return instance.getFloatNotNullNoDefaultNullValueException();
 612                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 613                         return instance.getFloatNullNoDefaultNullValueException();
 614                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 615                         return instance.getFloatNotNullDefaultNullValueException();
 616                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 617                         return instance.getFloatNullDefaultNullValueException();
 618                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 619                         return instance.getFloatNotNullNoDefaultNullValueDefault();
 620                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 621                         return instance.getFloatNullNoDefaultNullValueDefault();
 622                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 623                         return instance.getFloatNotNullDefaultNullValueDefault();
 624                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 625                         return instance.getFloatNullDefaultNullValueDefault();
 626                     default:
 627                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 628                 }
 629
 630             case 6: // Double
 631                 switch(fieldIndex) {
 632                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 633                         return instance.getDoubleNotNullNoDefaultNullValueNone();
 634                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
 635                         return instance.getDoubleNullNoDefaultNullValueNone();
 636                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 637                         return instance.getDoubleNotNullDefaultNullValueNone();
 638                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
 639                         return instance.getDoubleNullDefaultNullValueNone();
 640                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 641                         return instance.getDoubleNotNullNoDefaultNullValueException();
 642                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
 643                         return instance.getDoubleNullNoDefaultNullValueException();
 644                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 645                         return instance.getDoubleNotNullDefaultNullValueException();
 646                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
 647                         return instance.getDoubleNullDefaultNullValueException();
 648                     case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 649                         return instance.getDoubleNotNullNoDefaultNullValueDefault();
 650                     case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
 651                         return instance.getDoubleNullNoDefaultNullValueDefault();
 652                     case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 653                         return instance.getDoubleNotNullDefaultNullValueDefault();
 654                     case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
 655                         return instance.getDoubleNullDefaultNullValueDefault();
 656                     default:
 657                         throw new IllegalArgumentException("Illegal field index " + fieldIndex);
 658                 }
 659
 660             default:
 661                 throw new IllegalArgumentException("Illegal property type " + propertyType);
 662         }
 663     }
 664
 665 }