foundation/eclipselink.core.test/src/it/java/org/eclipse/persistence/testing/tests/types/NumericTester.java - eclipselink - Git at Google

 /*
  * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0,
  * or the Eclipse Distribution License v. 1.0 which is available at
  * http://www.eclipse.org/org/documents/edl-v10.php.
  *
  * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
  */

 // Contributors:
 //     Oracle - initial API and implementation from Oracle TopLink
 package org.eclipse.persistence.testing.tests.types;

 import java.util.*;
 import java.math.*;
 import org.eclipse.persistence.descriptors.RelationalDescriptor;
 import org.eclipse.persistence.sessions.Session;
 import org.eclipse.persistence.tools.schemaframework.*;
 import org.eclipse.persistence.testing.framework.*;
 import org.eclipse.persistence.internal.databaseaccess.*;

 /**
  * This test case will create a table consisting of a column to map to each of the JAVA data types.
  */
 public class NumericTester extends TypeTester {
     public int intValue;
     public Integer integerClassValue;
     public float floatValue;
     public Float floatClassValue;
     public long longValue;
     public Long longClassValue;
     public double doubleValue;
     public Double doubleClassValue;
     public short shortValue;
     public Short shortClassValue;
     public byte byteValue;
     public Byte byteClassValue;
     public BigInteger bigIntegerValue;
     public BigDecimal bigDecimalValue;

     public NumericTester() {
         super("ZERO");
         intValue = 0;
         integerClassValue = 0;
         floatValue = 0;
         floatClassValue = (float) 0;
         longValue = 0;
         longClassValue = 0L;
         doubleValue = 0;
         doubleClassValue = (double) 0;
         shortValue = (short)0;
         shortClassValue = (short) 0;
         byteValue = (byte)0;
         byteClassValue = (byte) 0;
         bigIntegerValue = new BigInteger("0");
         bigDecimalValue = new BigDecimal(bigIntegerValue, 19);
     }

     public NumericTester(String name) {
         super(name);
     }

     private static void addBigDecimalField(TableDefinition definition, DatabasePlatform platform) {
         FieldTypeDefinition fieldDef = platform.getFieldTypes().get(BigDecimal.class);

         if (fieldDef.isSizeAllowed()) {
             int scale = fieldDef.getMaxPrecision() / 2;
             definition.addField("BIGDECF", Float.class, fieldDef.getMaxPrecision(), scale);
         } else {
             definition.addField("BIGDECF", Float.class);
         }
     }

     /**
      * Assumes that if size is allowed that the sum of the scale and the precision
      * must be less than or equal to the maximum precision.
      *    If building sizes it splits the number (ie. 38 -{@literal >} 19,19 or 19 -{@literal >} 10, 9)
      */
     private static void addDoubleField(TableDefinition definition, DatabasePlatform platform) {
         FieldTypeDefinition fieldDef = platform.getFieldTypes().get(Double.class);

         if (fieldDef.isSizeAllowed()) {
             int scale = fieldDef.getMaxPrecision() / 2;
             definition.addField("DOUBLEF", Float.class, fieldDef.getMaxPrecision(), scale);
             definition.addField("DOUBLEFC", Float.class, fieldDef.getMaxPrecision(), scale);
         } else {
             definition.addField("DOUBLEF", Float.class);
             definition.addField("DOUBLEFC", Float.class);
         }
     }

     /**
      * Assumes that if size is allowed that the sum of the scale and the precision
      * must be less than or equal to the maximum precision.
      *    If building sizes it splits the number (ie. 38 -{@literal >} 19,19 or 19 -{@literal >} 10, 9)
      */
     private static void addFloatField(TableDefinition definition, DatabasePlatform platform) {
         FieldTypeDefinition fieldDef = platform.getFieldTypes().get(Float.class);

         if (fieldDef.isSizeAllowed()) {
             int scale = fieldDef.getMaxPrecision() / 2;
             definition.addField("FLOATF", Float.class, fieldDef.getMaxPrecision(), scale);
             definition.addField("FLOATFC", Float.class, fieldDef.getMaxPrecision(), scale);
         } else {
             definition.addField("FLOATF", Float.class);
             definition.addField("FLOATFC", Float.class);
         }
     }

     public static RelationalDescriptor descriptor() {
         RelationalDescriptor descriptor = new RelationalDescriptor();

         /* First define the class, table and descriptor properties. */
         descriptor.setJavaClass(NumericTester.class);
         descriptor.setTableName("NUMBERS");
         descriptor.setPrimaryKeyFieldName("NAME");

         /* Next define the attribute mappings. */
         descriptor.addDirectMapping("testName", "getTestName", "setTestName", "NAME");
         descriptor.addDirectMapping("intValue", "INTF");
         descriptor.addDirectMapping("integerClassValue", "INTFC");
         descriptor.addDirectMapping("floatValue", "FLOATF");
         descriptor.addDirectMapping("floatClassValue", "FLOATFC");
         descriptor.addDirectMapping("longValue", "LONGF");
         descriptor.addDirectMapping("longClassValue", "LONGFC");
         descriptor.addDirectMapping("doubleValue", "DOUBLEF");
         descriptor.addDirectMapping("doubleClassValue", "DOUBLEFC");
         descriptor.addDirectMapping("shortValue", "SHORTF");
         descriptor.addDirectMapping("shortClassValue", "SHORTFC");
         descriptor.addDirectMapping("byteValue", "BYTEF");
         descriptor.addDirectMapping("byteClassValue", "BYTEFC");
         descriptor.addDirectMapping("bigIntegerValue", "BIGINTF");
         descriptor.addDirectMapping("bigDecimalValue", "BIGDECF");

         return descriptor;
     }

     public static RelationalDescriptor descriptorWithAccessors() {
         RelationalDescriptor descriptor = new RelationalDescriptor();

         /* First define the class, table and descriptor properties. */
         descriptor.setJavaClass(NumericTester.class);
         descriptor.setTableName("NUMBERS");
         descriptor.setPrimaryKeyFieldName("NAME");

         /* Next define the attribute mappings. */
         descriptor.addDirectMapping("testName", "getTestName", "setTestName", "NAME");
         descriptor.addDirectMapping("intValue", "getIntegerValue", "setIntegerValue", "INTF");
         descriptor.addDirectMapping("integerClassValue", "getIntegerClassValue", "setIntegerClassValue", "INTFC");
         descriptor.addDirectMapping("floatValue", "getFloatValue", "setFloatValue", "FLOATF");
         descriptor.addDirectMapping("floatClassValue", "getFloatClassValue", "setFloatClassValue", "FLOATFC");
         descriptor.addDirectMapping("longValue", "getLongValue", "setLongValue", "LONGF");
         descriptor.addDirectMapping("longClassValue", "getLongClassValue", "setLongClassValue", "LONGFC");
         descriptor.addDirectMapping("doubleValue", "getDoubleValue", "setDoubleValue", "DOUBLEF");
         descriptor.addDirectMapping("doubleClassValue", "getDoubleClassValue", "setDoubleClassValue", "DOUBLEFC");
         descriptor.addDirectMapping("shortValue", "getShortValue", "setShortValue", "SHORTF");
         descriptor.addDirectMapping("shortClassValue", "getShortClassValue", "setShortClassValue", "SHORTFC");
         descriptor.addDirectMapping("byteValue", "getByteValue", "setByteValue", "BYTEF");
         descriptor.addDirectMapping("byteClassValue", "getByteClassValue", "setByteClassValue", "BYTEFC");
         descriptor.addDirectMapping("bigIntegerValue", "getBigIntegerValue", "setBigIntegerValue", "BIGINTF");
         descriptor.addDirectMapping("bigDecimalValue", "getBigDecimalValue", "setBigDecimalValue", "BIGDECF");
         return descriptor;
     }

     public BigDecimal getBigDecimalValue() {
         return bigDecimalValue;
     }

     public BigInteger getBigIntegerValue() {
         return bigIntegerValue;
     }

     public Byte getByteClassValue() {
         return byteClassValue;
     }

     public byte getByteValue() {
         return byteValue;
     }

     public Double getDoubleClassValue() {
         return doubleClassValue;
     }

     public double getDoubleValue() {
         return doubleValue;
     }

     public Float getFloatClassValue() {
         return floatClassValue;
     }

     public float getFloatValue() {
         return floatValue;
     }

     public Integer getIntegerClassValue() {
         return integerClassValue;
     }

     public int getIntegerValue() {
         return intValue;
     }

     public Long getLongClassValue() {
         return longClassValue;
     }

     public long getLongValue() {
         return longValue;
     }

     public Short getShortClassValue() {
         return shortClassValue;
     }

     public short getShortValue() {
         return shortValue;
     }

     protected static NumericTester maximumValues(DatabasePlatform platform) {
         NumericTester tester = new NumericTester("MAXIMUM");
         Hashtable maximums = platform.maximumNumericValues();

         tester.setIntegerValue((Integer) maximums.get(Integer.class));
         tester.setIntegerClassValue((Integer)maximums.get(Integer.class));
         tester.setFloatValue((Float) maximums.get(Float.class));
         tester.setFloatClassValue((Float)maximums.get(Float.class));
         tester.setLongValue((Long) maximums.get(Long.class));
         tester.setLongClassValue((Long)maximums.get(Long.class));
         tester.setDoubleValue((Double) maximums.get(Double.class));
         tester.setDoubleClassValue((Double)maximums.get(Double.class));
         tester.setShortValue((Short) maximums.get(Short.class));
         tester.setShortClassValue((Short)maximums.get(Short.class));
         tester.setByteValue((Byte) maximums.get(Byte.class));
         tester.setByteClassValue((Byte)maximums.get(Byte.class));
         tester.setBigIntegerValue((BigInteger)maximums.get(BigInteger.class));
         tester.setBigDecimalValue((BigDecimal)maximums.get(BigDecimal.class));

         return tester;
     }

     protected static NumericTester minimumValues(DatabasePlatform platform) {
         NumericTester tester = new NumericTester("MINIMUM");
         Hashtable minimums = platform.minimumNumericValues();

         tester.setIntegerValue((Integer) minimums.get(Integer.class));
         tester.setIntegerClassValue((Integer)minimums.get(Integer.class));
         tester.setFloatValue((Float) minimums.get(Float.class));
         tester.setFloatClassValue((Float)minimums.get(Float.class));
         tester.setLongValue((Long) minimums.get(Long.class));
         tester.setLongClassValue((Long)minimums.get(Long.class));
         tester.setDoubleValue((Double) minimums.get(Double.class));
         tester.setDoubleClassValue((Double)minimums.get(Double.class));
         tester.setShortValue((Short) minimums.get(Short.class));
         tester.setShortClassValue((Short)minimums.get(Short.class));
         tester.setByteValue((Byte) minimums.get(Byte.class));
         tester.setByteClassValue((Byte)minimums.get(Byte.class));
         tester.setBigIntegerValue((BigInteger)minimums.get(BigInteger.class));
         tester.setBigDecimalValue((BigDecimal)minimums.get(BigDecimal.class));

         return tester;
     }

     public void setBigDecimalValue(BigDecimal aBigDecimal) {
         bigDecimalValue = aBigDecimal;
     }

     public void setBigIntegerValue(BigInteger aBigInteger) {
         bigIntegerValue = aBigInteger;
     }

     public void setByteClassValue(byte aByte) {
         byteClassValue = aByte;
     }

     public void setByteClassValue(Byte aByte) {
         byteClassValue = aByte;
     }

     public void setByteValue(byte aByte) {
         byteValue = aByte;
     }

     public void setDoubleClassValue(double aDouble) {
         doubleClassValue = aDouble;
     }

     public void setDoubleClassValue(Double aDouble) {
         doubleClassValue = aDouble;
     }

     public void setDoubleValue(double aDouble) {
         doubleValue = aDouble;
     }

     public void setFloatClassValue(float aFloat) {
         floatClassValue = aFloat;
     }

     public void setFloatClassValue(Float aFloat) {
         floatClassValue = aFloat;
     }

     public void setFloatValue(float newFloat) {
         floatValue = newFloat;
     }

     public void setIntegerClassValue(int anInteger) {
         integerClassValue = anInteger;
     }

     public void setIntegerClassValue(Integer anInteger) {
         integerClassValue = anInteger;
     }

     public void setIntegerValue(int anInt) {
         intValue = anInt;
     }

     public void setLongClassValue(long aLong) {
         longClassValue = aLong;
     }

     public void setLongClassValue(Long aLong) {
         longClassValue = aLong;
     }

     public void setLongValue(long aLong) {
         longValue = aLong;
     }

     public void setShortClassValue(Short aShort) {
         shortClassValue = aShort;
     }

     public void setShortClassValue(short aShort) {
         shortClassValue = aShort;
     }

     public void setShortValue(short aShort) {
         shortValue = aShort;
     }

     public static TableDefinition tableDefinition(Session session) {
         DatabasePlatform platform = session.getPlatform();
         TableDefinition definition = TypeTester.tableDefinition();

         definition.setName("NUMBERS");
         definition.addField("INTF", Integer.class);
         definition.addField("INTFC", Integer.class);
         definition.addField("LONGF", Long.class);
         definition.addField("LONGFC", Long.class);
         definition.addField("SHORTF", Short.class);
         definition.addField("SHORTFC", Short.class);
         definition.addField("BYTEF", Byte.class);
         definition.addField("BYTEFC", Byte.class);
         addFloatField(definition, platform);
         addDoubleField(definition, platform);
         definition.addField("BIGINTF", BigInteger.class);
         addBigDecimalField(definition, platform);

         return definition;
     }

     /**
      *  Returns a vector of test instances (zero case, min case, max case)
      */
     public static Vector testInstances(Session session) {
         Vector tests = new Vector(3);

         tests.addElement(NumericTester.zeroValues(session.getPlatform()));
         tests.addElement(NumericTester.minimumValues(session.getPlatform()));
         tests.addElement(NumericTester.maximumValues(session.getPlatform()));
         return tests;
     }

     public String toString() {
         return "NumericTester(" + getTestName() + ")";
     }

     @Override
     protected void verify(WriteTypeObjectTest testCase) throws TestException {
         if(getTestName().equals("MINIMUM") || getTestName().equals("MAXIMUM")) {
             // Bug 210153
             throw new TestWarningException("MINIMUM and MAXIMUM tests fail on several platforms due to precision loss.");
         }
         try {
             super.verify(testCase);
         } catch (TestException exception) {
             if (testCase.getSession().getLogin().isJDBCODBCBridge()) {
                 throw new TestWarningException("This error occurred because driver data optimization is used " + "and JDBC-ODBC looses precision on numerics over 15 digits.");
             } else {
                 throw exception;
             }
         }
     }

     protected static NumericTester zeroValues(DatabasePlatform platform) {
         NumericTester tester = new NumericTester("ZERO");

         tester.setIntegerValue(0);
         tester.setIntegerClassValue(Integer.valueOf(0));
         tester.setFloatValue(0);
         tester.setFloatClassValue(Float.valueOf(0));
         tester.setLongValue(0);
         tester.setLongClassValue(Long.valueOf(0));
         tester.setDoubleValue(0);
         tester.setDoubleClassValue(Double.valueOf(0));
         tester.setShortValue((short)0);
         tester.setShortClassValue(Short.valueOf((short)0));
         tester.setByteValue((byte)0);
         tester.setByteClassValue(Byte.valueOf((byte)0));
         tester.setBigIntegerValue(new BigInteger("0"));
         tester.setBigDecimalValue(new BigDecimal("0"));

         return tester;
     }
 }
	/*
	* Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0,
	* or the Eclipse Distribution License v. 1.0 which is available at
	* http://www.eclipse.org/org/documents/edl-v10.php.
	*
	* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
	*/

	// Contributors:
	// Oracle - initial API and implementation from Oracle TopLink
	package org.eclipse.persistence.testing.tests.types;

	import java.util.*;
	import java.math.*;
	import org.eclipse.persistence.descriptors.RelationalDescriptor;
	import org.eclipse.persistence.sessions.Session;
	import org.eclipse.persistence.tools.schemaframework.*;
	import org.eclipse.persistence.testing.framework.*;
	import org.eclipse.persistence.internal.databaseaccess.*;

	/**
	* This test case will create a table consisting of a column to map to each of the JAVA data types.
	*/
	public class NumericTester extends TypeTester {
	public int intValue;
	public Integer integerClassValue;
	public float floatValue;
	public Float floatClassValue;
	public long longValue;
	public Long longClassValue;
	public double doubleValue;
	public Double doubleClassValue;
	public short shortValue;
	public Short shortClassValue;
	public byte byteValue;
	public Byte byteClassValue;
	public BigInteger bigIntegerValue;
	public BigDecimal bigDecimalValue;

	public NumericTester() {
	super("ZERO");
	intValue = 0;
	integerClassValue = 0;
	floatValue = 0;
	floatClassValue = (float) 0;
	longValue = 0;
	longClassValue = 0L;
	doubleValue = 0;
	doubleClassValue = (double) 0;
	shortValue = (short)0;
	shortClassValue = (short) 0;
	byteValue = (byte)0;
	byteClassValue = (byte) 0;
	bigIntegerValue = new BigInteger("0");
	bigDecimalValue = new BigDecimal(bigIntegerValue, 19);
	}

	public NumericTester(String name) {
	super(name);
	}

	private static void addBigDecimalField(TableDefinition definition, DatabasePlatform platform) {
	FieldTypeDefinition fieldDef = platform.getFieldTypes().get(BigDecimal.class);

	if (fieldDef.isSizeAllowed()) {
	int scale = fieldDef.getMaxPrecision() / 2;
	definition.addField("BIGDECF", Float.class, fieldDef.getMaxPrecision(), scale);
	} else {
	definition.addField("BIGDECF", Float.class);
	}
	}

	/**
	* Assumes that if size is allowed that the sum of the scale and the precision
	* must be less than or equal to the maximum precision.
	* If building sizes it splits the number (ie. 38 -{@literal >} 19,19 or 19 -{@literal >} 10, 9)
	*/
	private static void addDoubleField(TableDefinition definition, DatabasePlatform platform) {
	FieldTypeDefinition fieldDef = platform.getFieldTypes().get(Double.class);

	if (fieldDef.isSizeAllowed()) {
	int scale = fieldDef.getMaxPrecision() / 2;
	definition.addField("DOUBLEF", Float.class, fieldDef.getMaxPrecision(), scale);
	definition.addField("DOUBLEFC", Float.class, fieldDef.getMaxPrecision(), scale);
	} else {
	definition.addField("DOUBLEF", Float.class);
	definition.addField("DOUBLEFC", Float.class);
	}
	}

	/**
	* Assumes that if size is allowed that the sum of the scale and the precision
	* must be less than or equal to the maximum precision.
	* If building sizes it splits the number (ie. 38 -{@literal >} 19,19 or 19 -{@literal >} 10, 9)
	*/
	private static void addFloatField(TableDefinition definition, DatabasePlatform platform) {
	FieldTypeDefinition fieldDef = platform.getFieldTypes().get(Float.class);

	if (fieldDef.isSizeAllowed()) {
	int scale = fieldDef.getMaxPrecision() / 2;
	definition.addField("FLOATF", Float.class, fieldDef.getMaxPrecision(), scale);
	definition.addField("FLOATFC", Float.class, fieldDef.getMaxPrecision(), scale);
	} else {
	definition.addField("FLOATF", Float.class);
	definition.addField("FLOATFC", Float.class);
	}
	}

	public static RelationalDescriptor descriptor() {
	RelationalDescriptor descriptor = new RelationalDescriptor();

	/* First define the class, table and descriptor properties. */
	descriptor.setJavaClass(NumericTester.class);
	descriptor.setTableName("NUMBERS");
	descriptor.setPrimaryKeyFieldName("NAME");

	/* Next define the attribute mappings. */
	descriptor.addDirectMapping("testName", "getTestName", "setTestName", "NAME");
	descriptor.addDirectMapping("intValue", "INTF");
	descriptor.addDirectMapping("integerClassValue", "INTFC");
	descriptor.addDirectMapping("floatValue", "FLOATF");
	descriptor.addDirectMapping("floatClassValue", "FLOATFC");
	descriptor.addDirectMapping("longValue", "LONGF");
	descriptor.addDirectMapping("longClassValue", "LONGFC");
	descriptor.addDirectMapping("doubleValue", "DOUBLEF");
	descriptor.addDirectMapping("doubleClassValue", "DOUBLEFC");
	descriptor.addDirectMapping("shortValue", "SHORTF");
	descriptor.addDirectMapping("shortClassValue", "SHORTFC");
	descriptor.addDirectMapping("byteValue", "BYTEF");
	descriptor.addDirectMapping("byteClassValue", "BYTEFC");
	descriptor.addDirectMapping("bigIntegerValue", "BIGINTF");
	descriptor.addDirectMapping("bigDecimalValue", "BIGDECF");

	return descriptor;
	}

	public static RelationalDescriptor descriptorWithAccessors() {
	RelationalDescriptor descriptor = new RelationalDescriptor();

	/* First define the class, table and descriptor properties. */
	descriptor.setJavaClass(NumericTester.class);
	descriptor.setTableName("NUMBERS");
	descriptor.setPrimaryKeyFieldName("NAME");

	/* Next define the attribute mappings. */
	descriptor.addDirectMapping("testName", "getTestName", "setTestName", "NAME");
	descriptor.addDirectMapping("intValue", "getIntegerValue", "setIntegerValue", "INTF");
	descriptor.addDirectMapping("integerClassValue", "getIntegerClassValue", "setIntegerClassValue", "INTFC");
	descriptor.addDirectMapping("floatValue", "getFloatValue", "setFloatValue", "FLOATF");
	descriptor.addDirectMapping("floatClassValue", "getFloatClassValue", "setFloatClassValue", "FLOATFC");
	descriptor.addDirectMapping("longValue", "getLongValue", "setLongValue", "LONGF");
	descriptor.addDirectMapping("longClassValue", "getLongClassValue", "setLongClassValue", "LONGFC");
	descriptor.addDirectMapping("doubleValue", "getDoubleValue", "setDoubleValue", "DOUBLEF");
	descriptor.addDirectMapping("doubleClassValue", "getDoubleClassValue", "setDoubleClassValue", "DOUBLEFC");
	descriptor.addDirectMapping("shortValue", "getShortValue", "setShortValue", "SHORTF");
	descriptor.addDirectMapping("shortClassValue", "getShortClassValue", "setShortClassValue", "SHORTFC");
	descriptor.addDirectMapping("byteValue", "getByteValue", "setByteValue", "BYTEF");
	descriptor.addDirectMapping("byteClassValue", "getByteClassValue", "setByteClassValue", "BYTEFC");
	descriptor.addDirectMapping("bigIntegerValue", "getBigIntegerValue", "setBigIntegerValue", "BIGINTF");
	descriptor.addDirectMapping("bigDecimalValue", "getBigDecimalValue", "setBigDecimalValue", "BIGDECF");
	return descriptor;
	}

	public BigDecimal getBigDecimalValue() {
	return bigDecimalValue;
	}

	public BigInteger getBigIntegerValue() {
	return bigIntegerValue;
	}

	public Byte getByteClassValue() {
	return byteClassValue;
	}

	public byte getByteValue() {
	return byteValue;
	}

	public Double getDoubleClassValue() {
	return doubleClassValue;
	}

	public double getDoubleValue() {
	return doubleValue;
	}

	public Float getFloatClassValue() {
	return floatClassValue;
	}

	public float getFloatValue() {
	return floatValue;
	}

	public Integer getIntegerClassValue() {
	return integerClassValue;
	}

	public int getIntegerValue() {
	return intValue;
	}

	public Long getLongClassValue() {
	return longClassValue;
	}

	public long getLongValue() {
	return longValue;
	}

	public Short getShortClassValue() {
	return shortClassValue;
	}

	public short getShortValue() {
	return shortValue;
	}

	protected static NumericTester maximumValues(DatabasePlatform platform) {
	NumericTester tester = new NumericTester("MAXIMUM");
	Hashtable maximums = platform.maximumNumericValues();

	tester.setIntegerValue((Integer) maximums.get(Integer.class));
	tester.setIntegerClassValue((Integer)maximums.get(Integer.class));
	tester.setFloatValue((Float) maximums.get(Float.class));
	tester.setFloatClassValue((Float)maximums.get(Float.class));
	tester.setLongValue((Long) maximums.get(Long.class));
	tester.setLongClassValue((Long)maximums.get(Long.class));
	tester.setDoubleValue((Double) maximums.get(Double.class));
	tester.setDoubleClassValue((Double)maximums.get(Double.class));
	tester.setShortValue((Short) maximums.get(Short.class));
	tester.setShortClassValue((Short)maximums.get(Short.class));
	tester.setByteValue((Byte) maximums.get(Byte.class));
	tester.setByteClassValue((Byte)maximums.get(Byte.class));
	tester.setBigIntegerValue((BigInteger)maximums.get(BigInteger.class));
	tester.setBigDecimalValue((BigDecimal)maximums.get(BigDecimal.class));

	return tester;
	}

	protected static NumericTester minimumValues(DatabasePlatform platform) {
	NumericTester tester = new NumericTester("MINIMUM");
	Hashtable minimums = platform.minimumNumericValues();

	tester.setIntegerValue((Integer) minimums.get(Integer.class));
	tester.setIntegerClassValue((Integer)minimums.get(Integer.class));
	tester.setFloatValue((Float) minimums.get(Float.class));
	tester.setFloatClassValue((Float)minimums.get(Float.class));
	tester.setLongValue((Long) minimums.get(Long.class));
	tester.setLongClassValue((Long)minimums.get(Long.class));
	tester.setDoubleValue((Double) minimums.get(Double.class));
	tester.setDoubleClassValue((Double)minimums.get(Double.class));
	tester.setShortValue((Short) minimums.get(Short.class));
	tester.setShortClassValue((Short)minimums.get(Short.class));
	tester.setByteValue((Byte) minimums.get(Byte.class));
	tester.setByteClassValue((Byte)minimums.get(Byte.class));
	tester.setBigIntegerValue((BigInteger)minimums.get(BigInteger.class));
	tester.setBigDecimalValue((BigDecimal)minimums.get(BigDecimal.class));

	return tester;
	}

	public void setBigDecimalValue(BigDecimal aBigDecimal) {
	bigDecimalValue = aBigDecimal;
	}

	public void setBigIntegerValue(BigInteger aBigInteger) {
	bigIntegerValue = aBigInteger;
	}

	public void setByteClassValue(byte aByte) {
	byteClassValue = aByte;
	}

	public void setByteClassValue(Byte aByte) {
	byteClassValue = aByte;
	}

	public void setByteValue(byte aByte) {
	byteValue = aByte;
	}

	public void setDoubleClassValue(double aDouble) {
	doubleClassValue = aDouble;
	}

	public void setDoubleClassValue(Double aDouble) {
	doubleClassValue = aDouble;
	}

	public void setDoubleValue(double aDouble) {
	doubleValue = aDouble;
	}

	public void setFloatClassValue(float aFloat) {
	floatClassValue = aFloat;
	}

	public void setFloatClassValue(Float aFloat) {
	floatClassValue = aFloat;
	}

	public void setFloatValue(float newFloat) {
	floatValue = newFloat;
	}

	public void setIntegerClassValue(int anInteger) {
	integerClassValue = anInteger;
	}

	public void setIntegerClassValue(Integer anInteger) {
	integerClassValue = anInteger;
	}

	public void setIntegerValue(int anInt) {
	intValue = anInt;
	}

	public void setLongClassValue(long aLong) {
	longClassValue = aLong;
	}

	public void setLongClassValue(Long aLong) {
	longClassValue = aLong;
	}

	public void setLongValue(long aLong) {
	longValue = aLong;
	}

	public void setShortClassValue(Short aShort) {
	shortClassValue = aShort;
	}

	public void setShortClassValue(short aShort) {
	shortClassValue = aShort;
	}

	public void setShortValue(short aShort) {
	shortValue = aShort;
	}

	public static TableDefinition tableDefinition(Session session) {
	DatabasePlatform platform = session.getPlatform();
	TableDefinition definition = TypeTester.tableDefinition();

	definition.setName("NUMBERS");
	definition.addField("INTF", Integer.class);
	definition.addField("INTFC", Integer.class);
	definition.addField("LONGF", Long.class);
	definition.addField("LONGFC", Long.class);
	definition.addField("SHORTF", Short.class);
	definition.addField("SHORTFC", Short.class);
	definition.addField("BYTEF", Byte.class);
	definition.addField("BYTEFC", Byte.class);
	addFloatField(definition, platform);
	addDoubleField(definition, platform);
	definition.addField("BIGINTF", BigInteger.class);
	addBigDecimalField(definition, platform);

	return definition;
	}

	/**
	* Returns a vector of test instances (zero case, min case, max case)
	*/
	public static Vector testInstances(Session session) {
	Vector tests = new Vector(3);

	tests.addElement(NumericTester.zeroValues(session.getPlatform()));
	tests.addElement(NumericTester.minimumValues(session.getPlatform()));
	tests.addElement(NumericTester.maximumValues(session.getPlatform()));
	return tests;
	}

	public String toString() {
	return "NumericTester(" + getTestName() + ")";
	}

	@Override
	protected void verify(WriteTypeObjectTest testCase) throws TestException {
	if(getTestName().equals("MINIMUM") \|\| getTestName().equals("MAXIMUM")) {
	// Bug 210153
	throw new TestWarningException("MINIMUM and MAXIMUM tests fail on several platforms due to precision loss.");
	}
	try {
	super.verify(testCase);
	} catch (TestException exception) {
	if (testCase.getSession().getLogin().isJDBCODBCBridge()) {
	throw new TestWarningException("This error occurred because driver data optimization is used " + "and JDBC-ODBC looses precision on numerics over 15 digits.");
	} else {
	throw exception;
	}
	}
	}

	protected static NumericTester zeroValues(DatabasePlatform platform) {
	NumericTester tester = new NumericTester("ZERO");

	tester.setIntegerValue(0);
	tester.setIntegerClassValue(Integer.valueOf(0));
	tester.setFloatValue(0);
	tester.setFloatClassValue(Float.valueOf(0));
	tester.setLongValue(0);
	tester.setLongClassValue(Long.valueOf(0));
	tester.setDoubleValue(0);
	tester.setDoubleClassValue(Double.valueOf(0));
	tester.setShortValue((short)0);
	tester.setShortClassValue(Short.valueOf((short)0));
	tester.setByteValue((byte)0);
	tester.setByteClassValue(Byte.valueOf((byte)0));
	tester.setBigIntegerValue(new BigInteger("0"));
	tester.setBigDecimalValue(new BigDecimal("0"));

	return tester;
	}
	}