/*******************************************************************************
* Copyright (c) 1998, 2015 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 v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* 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 = new Integer(0);
floatValue = 0;
floatClassValue = new Float(0);
longValue = 0;
longClassValue = new Long(0);
doubleValue = 0;
doubleClassValue = new Double(0);
shortValue = (short)0;
shortClassValue = new Short((short)0);
byteValue = (byte)0;
byteClassValue = new Byte((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 -> 19,19 or 19 -> 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 -> 19,19 or 19 -> 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)).intValue());
tester.setIntegerClassValue((Integer)maximums.get(Integer.class));
tester.setFloatValue(((Float)maximums.get(Float.class)).floatValue());
tester.setFloatClassValue((Float)maximums.get(Float.class));
tester.setLongValue(((Long)maximums.get(Long.class)).longValue());
tester.setLongClassValue((Long)maximums.get(Long.class));
tester.setDoubleValue(((Double)maximums.get(Double.class)).doubleValue());
tester.setDoubleClassValue((Double)maximums.get(Double.class));
tester.setShortValue(((Short)maximums.get(Short.class)).shortValue());
tester.setShortClassValue((Short)maximums.get(Short.class));
tester.setByteValue(((Byte)maximums.get(Byte.class)).byteValue());
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)).intValue());
tester.setIntegerClassValue((Integer)minimums.get(Integer.class));
tester.setFloatValue(((Float)minimums.get(Float.class)).floatValue());
tester.setFloatClassValue((Float)minimums.get(Float.class));
tester.setLongValue(((Long)minimums.get(Long.class)).longValue());
tester.setLongClassValue((Long)minimums.get(Long.class));
tester.setDoubleValue(((Double)minimums.get(Double.class)).doubleValue());
tester.setDoubleClassValue((Double)minimums.get(Double.class));
tester.setShortValue(((Short)minimums.get(Short.class)).shortValue());
tester.setShortClassValue((Short)minimums.get(Short.class));
tester.setByteValue(((Byte)minimums.get(Byte.class)).byteValue());
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 = new Byte(aByte);
}
public void setByteClassValue(Byte aByte) {
byteClassValue = aByte;
}
public void setByteValue(byte aByte) {
byteValue = aByte;
}
public void setDoubleClassValue(double aDouble) {
doubleClassValue = new Double(aDouble);
}
public void setDoubleClassValue(Double aDouble) {
doubleClassValue = aDouble;
}
public void setDoubleValue(double aDouble) {
doubleValue = aDouble;
}
public void setFloatClassValue(float aFloat) {
floatClassValue = new Float(aFloat);
}
public void setFloatClassValue(Float aFloat) {
floatClassValue = aFloat;
}
public void setFloatValue(float newFloat) {
floatValue = newFloat;
}
public void setIntegerClassValue(int anInteger) {
integerClassValue = new Integer(anInteger);
}
public void setIntegerClassValue(Integer anInteger) {
integerClassValue = anInteger;
}
public void setIntegerValue(int anInt) {
intValue = anInt;
}
public void setLongClassValue(long aLong) {
longClassValue = new Long(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 = new Short(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() + ")";
}
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(new Integer(0));
tester.setFloatValue(0);
tester.setFloatClassValue(new Float(0));
tester.setLongValue(0);
tester.setLongClassValue(new Long(0));
tester.setDoubleValue(0);
tester.setDoubleClassValue(new Double(0));
tester.setShortValue((short)0);
tester.setShortClassValue(new Short((short)0));
tester.setByteValue((byte)0);
tester.setByteClassValue(new Byte((byte)0));
tester.setBigIntegerValue(new BigInteger("0"));
tester.setBigDecimalValue(new BigDecimal("0"));
return tester;
}
}