You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@drill.apache.org by pa...@apache.org on 2015/04/13 20:09:02 UTC
[2/4] drill git commit: DRILL-2613: 2-Core: Impl.
ResultSet.getXxx(...) number-to-number data conversions.
http://git-wip-us.apache.org/repos/asf/drill/blob/fe11e86c/exec/jdbc/src/test/java/org/apache/drill/jdbc/impl/TypeConvertingSqlAccessorTest.java
----------------------------------------------------------------------
diff --git a/exec/jdbc/src/test/java/org/apache/drill/jdbc/impl/TypeConvertingSqlAccessorTest.java b/exec/jdbc/src/test/java/org/apache/drill/jdbc/impl/TypeConvertingSqlAccessorTest.java
new file mode 100644
index 0000000..a595ed4
--- /dev/null
+++ b/exec/jdbc/src/test/java/org/apache/drill/jdbc/impl/TypeConvertingSqlAccessorTest.java
@@ -0,0 +1,849 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.drill.jdbc.impl;
+
+import static org.junit.Assert.*;
+
+import org.apache.drill.common.types.Types;
+import org.apache.drill.common.types.TypeProtos.MajorType;
+import org.apache.drill.common.types.TypeProtos.MinorType;
+import org.apache.drill.exec.vector.accessor.AbstractSqlAccessor;
+import org.apache.drill.exec.vector.accessor.InvalidAccessException;
+import org.apache.drill.exec.vector.accessor.SqlAccessor;
+import org.apache.drill.jdbc.SQLConversionOverflowException;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.fail;
+import static org.junit.Assert.assertThat;
+import static org.hamcrest.CoreMatchers.*;
+
+/**
+ * Class-level unit test for {@link TypeConvertingSqlAccessor}.
+ * (Also see {@link org.apache.drill.jdbcResultSetGetMethodConversionsTest}.
+ */
+public class TypeConvertingSqlAccessorTest {
+
+ /**
+ * Base test stub(?) for accessors underlying TypeConvertingSqlAccessor.
+ * Carries type and (Object form of) one value.
+ */
+ private static abstract class BaseStubAccessor extends AbstractSqlAccessor
+ implements SqlAccessor {
+ private final MajorType type;
+ private final Object value;
+
+ BaseStubAccessor( MajorType type, Object value )
+ {
+ this.type = type;
+ this.value = value;
+ }
+
+ @Override
+ public MajorType getType() {
+ return type;
+ }
+
+ protected Object getValue() {
+ return value;
+ }
+
+ @Override
+ public boolean isNull( int rowOffset ) {
+ return false;
+ }
+
+ @Override
+ public Object getObject( int rowOffset ) throws InvalidAccessException {
+ throw new RuntimeException( "Unexpected use of getObject(...)" );
+ }
+
+ }
+
+ // Byte? TinyInt? TINYINT?
+ private static class TinyIntStubAccessor extends BaseStubAccessor {
+ TinyIntStubAccessor( byte value ) {
+ super( Types.required( MinorType.TINYINT ), value );
+ }
+
+ public byte getByte( int rowOffset ) {
+ return (Byte) getValue();
+ }
+ } // TinyIntStubAccessor
+
+
+ // Short? SmallInt? SMALLINT?
+ private static class SmallIntStubAccessor extends BaseStubAccessor {
+ SmallIntStubAccessor( short value ) {
+ super( Types.required( MinorType.SMALLINT ), value );
+ }
+
+ public short getShort( int rowOffset ) {
+ return (Short) getValue();
+ }
+ } // SmallIntStubAccessor
+
+
+ // Int? Int? INT?
+ private static class IntegerStubAccessor extends BaseStubAccessor {
+ IntegerStubAccessor( int value ) {
+ super( Types.required( MinorType.INT ), value );
+ }
+
+ public int getInt( int rowOffset ) {
+ return (Integer) getValue();
+ }
+ } // IntegerStubAccessor
+
+
+ // Long? Bigint? BIGINT?
+ private static class BigIntStubAccessor extends BaseStubAccessor {
+ BigIntStubAccessor( long value ) {
+ super( Types.required( MinorType.BIGINT ), value );
+ }
+
+ public long getLong( int rowOffset ) {
+ return (Long) getValue();
+ }
+ } // BigIntStubAccessor
+
+
+ // Float? Float4? FLOAT? (REAL?)
+ private static class FloatStubAccessor extends BaseStubAccessor {
+ FloatStubAccessor( float value ) {
+ super( Types.required( MinorType.FLOAT4 ), value );
+ }
+
+ public float getFloat( int rowOffset ) {
+ return (Float) getValue();
+ }
+ } // FloatStubAccessor
+
+ // Double? Float8? DOUBLE?
+ private static class DoubleStubAccessor extends BaseStubAccessor {
+ DoubleStubAccessor( double value ) {
+ super( Types.required( MinorType.FLOAT8 ), value );
+ }
+
+ public double getDouble( int rowOffset ) {
+ return (double) getValue();
+ }
+ } // DoubleStubAccessor
+
+
+ //////////////////////////////////////////////////////////////////////
+ // Column accessor (getXxx(...)) methods, in same order as in JDBC 4.2 spec.
+ // TABLE B-6 ("Use of ResultSet getter Methods to Retrieve JDBC Data Types"):
+
+ ////////////////////////////////////////
+ // - getByte:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+ // - ROWID;
+
+ @Test
+ public void test_getByte_on_TINYINT_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new TinyIntStubAccessor( (byte) 127 ) );
+ assertThat( uut1.getByte( 0 ), equalTo( (byte) 127 ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new TinyIntStubAccessor( (byte) -128 ) );
+ assertThat( uut2.getByte( 0 ), equalTo( (byte) -128 ) );
+ }
+
+ @Test
+ public void test_getByte_on_SMALLINT_thatFits_getsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new SmallIntStubAccessor( (short) 127 ) );
+ assertThat( uut.getByte( 0 ), equalTo( (byte) 127 ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getByte_on_SMALLINT_thatOverflows_rejectsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new SmallIntStubAccessor( (short) 128 ) );
+ try {
+ uut.getByte( 0 );
+ }
+ catch ( Throwable e ) {
+ // Expect the too-big source value in error message:
+ assertThat( e.getMessage(), containsString( "128" ) );
+ // Probably expect the method name:
+ assertThat( e.getMessage(), containsString( "getByte" ) );
+ // Expect something about source type (original SQL type and default Java
+ // type, currently).
+ assertThat( e.getMessage(), allOf( containsString( "short" ),
+ containsString( "SMALLINT" ) ) );
+ throw e;
+ }
+ }
+
+ @Test
+ public void test_getByte_on_INTEGER_thatFits_getsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new IntegerStubAccessor( -128 ) );
+ assertThat( uut.getByte( 0 ), equalTo( (byte) -128 ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getByte_on_INTEGER_thatOverflows_rejectsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new IntegerStubAccessor( -129 ) );
+ try {
+ uut.getByte( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "-129" ) );
+ assertThat( e.getMessage(), containsString( "getByte" ) );
+ assertThat( e.getMessage(), allOf( containsString( "int" ),
+ containsString( "INTEGER" ) ) );
+ throw e;
+ }
+ }
+
+ @Test
+ public void test_getByte_on_BIGINT_thatFits_getsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new BigIntStubAccessor( -128 ) );
+ assertThat( uut.getByte( 0 ), equalTo( (byte) -128 ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getByte_on_BIGINT_thatOverflows_rejectsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new BigIntStubAccessor( 129 ) );
+ try {
+ uut.getByte( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "129" ) );
+ assertThat( e.getMessage(), containsString( "getByte" ) );
+ assertThat( e.getMessage(), allOf( containsString( "long" ),
+ containsString( "BIGINT" ) ) );
+ throw e;
+ }
+ }
+
+ @Test
+ public void test_getByte_on_FLOAT_thatFits_getsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( -128.0f ) );
+ assertThat( uut.getByte( 0 ), equalTo( (byte) -128 ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getByte_on_FLOAT_thatOverflows_rejectsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( -130f ) );
+ try {
+ uut.getByte( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "-130" ) );
+ assertThat( e.getMessage(), containsString( "getByte" ) );
+ assertThat( e.getMessage(), allOf( containsString( "float" ),
+ anyOf( containsString( "REAL" ),
+ containsString( "FLOAT" ) ) ) );
+ throw e;
+ }
+ }
+
+ @Test
+ public void test_getByte_on_DOUBLE_thatFits_getsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( 127.0d ) );
+ assertThat( uut.getByte( 0 ), equalTo( (byte) 127) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getByte_on_DOUBLE_thatOverflows_rejectsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( -130 ) );
+ try {
+ uut.getByte( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "-130" ) );
+ assertThat( e.getMessage(), containsString( "getByte" ) );
+ assertThat( e.getMessage(), allOf( containsString( "double" ),
+ anyOf( containsString( "DOUBLE PRECISION" ),
+ containsString( "FLOAT(" ) ) ) );
+ throw e;
+ }
+ }
+
+ ////////////////////////////////////////
+ // - getShort:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+
+ @Test
+ public void test_getShort_on_TINYINT_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new TinyIntStubAccessor( (byte) 127 ) );
+ assertThat( uut1.getShort( 0 ), equalTo( (short) 127 ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new TinyIntStubAccessor( (byte) -128 ) );
+ assertThat( uut2.getShort( 0 ), equalTo( (short) -128 ) );
+ }
+
+ @Test
+ public void test_getShort_on_SMALLINT_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new SmallIntStubAccessor( (short) 32767 ) );
+ assertThat( uut1.getShort( 0 ), equalTo( (short) 32767 ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new SmallIntStubAccessor( (short) -32768 ) );
+ assertThat( uut2.getShort( 0 ), equalTo( (short) -32768 ) );
+ }
+
+ @Test
+ public void test_getShort_on_INTEGER_thatFits_getsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new IntegerStubAccessor( 32767 ) );
+ assertThat( uut1.getShort( 0 ), equalTo( (short) 32767 ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new IntegerStubAccessor( -32768 ) );
+ assertThat( uut2.getShort( 0 ), equalTo( (short) -32768 ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getShort_on_INTEGER_thatOverflows_throws()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new IntegerStubAccessor( -32769 ) );
+ try {
+ uut.getShort( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "-32769" ) );
+ assertThat( e.getMessage(), containsString( "getShort" ) );
+ assertThat( e.getMessage(), allOf( containsString( "int" ),
+ containsString( "INTEGER" ) ) );
+ throw e;
+ }
+ }
+
+ @Test
+ public void test_getShort_BIGINT_thatFits_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new BigIntStubAccessor( -32678 ) );
+ assertThat( uut.getShort( 0 ), equalTo( (short) -32678 ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getShort_on_BIGINT_thatOverflows_throws()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new BigIntStubAccessor( 65535 ) );
+ try {
+ uut.getShort( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "65535" ) );
+ assertThat( e.getMessage(), containsString( "getShort" ) );
+ assertThat( e.getMessage(), allOf( containsString( "long" ),
+ containsString( "BIGINT" ) ) );
+ throw e;
+ }
+ }
+
+ @Test
+ public void test_getShort_on_FLOAT_thatFits_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( -32768f ) );
+ assertThat( uut.getShort( 0 ), equalTo( (short) -32768 ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getShort_on_FLOAT_thatOverflows_rejectsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( -32769f ) );
+ try {
+ uut.getShort( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "-32769" ) );
+ assertThat( e.getMessage(), containsString( "getShort" ) );
+ assertThat( e.getMessage(), allOf( containsString( "float" ),
+ anyOf( containsString( "REAL" ),
+ containsString( "FLOAT" ) ) ) );
+ throw e;
+ }
+ }
+
+ @Test
+ public void test_getShort_on_DOUBLE_thatFits_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( 32767d ) );
+ assertThat( uut.getShort( 0 ), equalTo( (short) 32767) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getShort_on_DOUBLE_thatOverflows_rejectsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( 32768 ) );
+ try {
+ uut.getShort( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "32768" ) );
+ assertThat( e.getMessage(), containsString( "getShort" ) );
+ assertThat( e.getMessage(), allOf( containsString( "double" ),
+ anyOf( containsString( "DOUBLE PRECISION" ),
+ containsString( "FLOAT" ) ) ) );
+ throw e;
+ }
+ }
+
+
+ ////////////////////////////////////////
+ // - getInt:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+
+ @Test
+ public void test_getInt_on_TINYINT_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new TinyIntStubAccessor( (byte) 127 ) );
+ assertThat( uut1.getInt( 0 ), equalTo( 127 ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new TinyIntStubAccessor( (byte) -128 ) );
+ assertThat( uut2.getInt( 0 ), equalTo( -128 ) );
+ }
+
+ @Test
+ public void test_getInt_on_SMALLINT_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new SmallIntStubAccessor( (short) 32767 ) );
+ assertThat( uut1.getInt( 0 ), equalTo( 32767 ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new SmallIntStubAccessor( (short) -32768 ) );
+ assertThat( uut2.getInt( 0 ), equalTo( -32768 ) );
+ }
+
+ @Test
+ public void test_getInt_on_INTEGER_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new IntegerStubAccessor( 2147483647 ) );
+ assertThat( uut1.getInt( 0 ), equalTo( 2147483647 ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new IntegerStubAccessor( -2147483648 ) );
+ assertThat( uut2.getInt( 0 ), equalTo( -2147483648 ) );
+ }
+
+ @Test
+ public void test_getInt_on_BIGINT_thatFits_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new BigIntStubAccessor( 2147483647 ) );
+ assertThat( uut.getInt( 0 ), equalTo( 2147483647 ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getInt_on_BIGINT_thatOverflows_throws() throws
+ InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new BigIntStubAccessor( 2147483648L ) );
+ try {
+ uut.getInt( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "2147483648" ) );
+ assertThat( e.getMessage(), containsString( "getInt" ) );
+ assertThat( e.getMessage(), allOf( containsString( "long" ),
+ containsString( "BIGINT" ) ) );
+ throw e;
+ }
+ }
+
+ @Test
+ public void test_getInt_on_FLOAT_thatFits_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( 1e9f ) );
+ assertThat( uut.getInt( 0 ), equalTo( 1_000_000_000 ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getInt_on_FLOAT_thatOverflows_rejectsIt() throws
+ InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( 1e10f ) );
+ try {
+ uut.getInt( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "1.0E10" ) );
+ assertThat( e.getMessage(), containsString( "getInt" ) );
+ assertThat( e.getMessage(), allOf( containsString( "float" ),
+ anyOf( containsString( "REAL" ),
+ containsString( "FLOAT" ) ) ) );
+ throw e;
+ }
+ }
+
+ @Test
+ public void test_getInt_on_DOUBLE_thatFits_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( -2147483648.0d ) );
+ assertThat( uut.getInt( 0 ), equalTo( -2147483648 ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getInt_on_DOUBLE_thatOverflows_rejectsIt() throws
+ InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( -2147483649.0d ) );
+ try {
+ uut.getInt( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "-2.147483649E9" ) );
+ assertThat( e.getMessage(), containsString( "getInt" ) );
+ assertThat( e.getMessage(), allOf( containsString( "double" ),
+ containsString( "DOUBLE PRECISION" ) ) );
+ throw e;
+ }
+ }
+
+
+ ////////////////////////////////////////
+ // - getLong:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+
+ @Test
+ public void test_getLong_on_TINYINT_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new TinyIntStubAccessor( (byte) 127 ) );
+ assertThat( uut1.getLong( 0 ), equalTo( 127L ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new TinyIntStubAccessor( (byte) -128 ) );
+ assertThat( uut2.getLong( 0 ), equalTo( -128L ) );
+ }
+
+ @Test
+ public void test_getLong_on_SMALLINT_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new SmallIntStubAccessor( (short) 32767 ) );
+ assertThat( uut1.getLong( 0 ), equalTo( 32767L ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new SmallIntStubAccessor( (short) -32768 ) );
+ assertThat( uut2.getLong( 0 ), equalTo( -32768L ) );
+ }
+
+ @Test
+ public void test_getLong_on_INTEGER_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new IntegerStubAccessor( 2147483647 ) );
+ assertThat( uut1.getLong( 0 ), equalTo( 2147483647L ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new IntegerStubAccessor( -2147483648 ) );
+ assertThat( uut2.getLong( 0 ), equalTo( -2147483648L ) );
+ }
+
+ @Test
+ public void test_getLong_on_BIGINT_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new BigIntStubAccessor( 2147483648L ) );
+ assertThat( uut.getLong( 0 ), equalTo( 2147483648L ) );
+ }
+
+ @Test
+ public void test_getLong_on_FLOAT_thatFits_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor(
+ new FloatStubAccessor( 9223372036854775807L * 1.0f ) );
+ assertThat( uut.getLong( 0 ), equalTo( 9223372036854775807L ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getLong_on_FLOAT_thatOverflows_rejectsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( 1.5e20f ) );
+ try {
+ uut.getLong( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "1.5000" ) );
+ assertThat( e.getMessage(), containsString( "getLong" ) );
+ assertThat( e.getMessage(), allOf( containsString( "float" ),
+ anyOf( containsString( "REAL" ),
+ containsString( "FLOAT" ) ) ) );
+ throw e;
+ }
+ }
+
+ @Test
+ public void test_getLong_on_DOUBLE_thatFits_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor(
+ new DoubleStubAccessor( 9223372036854775807L * 1.0d ) );
+ assertThat( uut.getLong( 0 ), equalTo( 9223372036854775807L ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getLong_on_DOUBLE_thatOverflows_rejectsIt()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( 1e20 ) );
+ try {
+ uut.getLong( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "1.0E20" ) );
+ assertThat( e.getMessage(), containsString( "getLong" ) );
+ assertThat( e.getMessage(), allOf( containsString( "double" ),
+ containsString( "DOUBLE PRECISION" ) ) );
+ throw e;
+ }
+ }
+
+
+
+ ////////////////////////////////////////
+ // - getFloat:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+
+ @Test
+ public void test_getFloat_on_FLOAT_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( 1.23f ) );
+ assertThat( uut1.getFloat( 0 ), equalTo( 1.23f ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( Float.MAX_VALUE ) );
+ assertThat( uut2.getFloat( 0 ), equalTo( Float.MAX_VALUE ) );
+ final SqlAccessor uut3 =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( Float.MIN_VALUE ) );
+ assertThat( uut3.getFloat( 0 ), equalTo( Float.MIN_VALUE ) );
+ }
+
+ @Test
+ public void test_getFloat_on_DOUBLE_thatFits_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( 1.125 ) );
+ assertThat( uut1.getFloat( 0 ), equalTo( 1.125f ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( Float.MAX_VALUE ) );
+ assertThat( uut2.getFloat( 0 ), equalTo( Float.MAX_VALUE ) );
+ }
+
+ @Test( expected = SQLConversionOverflowException.class )
+ public void test_getFloat_on_DOUBLE_thatOverflows_throws()
+ throws InvalidAccessException {
+ final SqlAccessor uut =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( 1e100 ) );
+ try {
+ uut.getFloat( 0 );
+ }
+ catch ( Throwable e ) {
+ assertThat( e.getMessage(), containsString( "1.0E100" ) );
+ assertThat( e.getMessage(), containsString( "getFloat" ) );
+ assertThat( e.getMessage(), allOf( containsString( "double" ),
+ anyOf ( containsString( "DOUBLE PRECISION" ),
+ containsString( "FLOAT" ) ) ) );
+ throw e;
+ }
+ }
+
+
+ ////////////////////////////////////////
+ // - getDouble:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+
+ @Test
+ public void test_getDouble_on_FLOAT_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( 6.02e23f ) );
+ assertThat( uut1.getDouble( 0 ), equalTo( (double) 6.02e23f ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( Float.MAX_VALUE ) );
+ assertThat( uut2.getDouble( 0 ), equalTo( (double) Float.MAX_VALUE ) );
+ final SqlAccessor uut3 =
+ new TypeConvertingSqlAccessor( new FloatStubAccessor( Float.MIN_VALUE ) );
+ assertThat( uut3.getDouble( 0 ), equalTo( (double) Float.MIN_VALUE ) );
+ }
+
+ @Test
+ public void test_getDouble_on_DOUBLE_getsIt() throws InvalidAccessException {
+ final SqlAccessor uut1 =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( -1e100 ) );
+ assertThat( uut1.getDouble( 0 ), equalTo( -1e100 ) );
+ final SqlAccessor uut2 =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( Double.MAX_VALUE ) );
+ assertThat( uut2.getDouble( 0 ), equalTo( Double.MAX_VALUE ) );
+ final SqlAccessor uut3 =
+ new TypeConvertingSqlAccessor( new DoubleStubAccessor( Double.MIN_VALUE ) );
+ assertThat( uut3.getDouble( 0 ), equalTo( Double.MIN_VALUE ) );
+ }
+
+ ////////////////////////////////////////
+ // - getBigDecimal:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+
+ ////////////////////////////////////////
+ // - getBoolean:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+
+ ////////////////////////////////////////
+ // - getString:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+ // - NCHAR, NVARCHAR, LONGNVARCHAR;
+ // - BINARY, VARBINARY, LONGVARBINARY;
+ // - DATE, TIME, TIMESTAMP;
+ // - DATALINK;
+
+ ////////////////////////////////////////
+ // - getNString:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+ // - NCHAR, NVARCHAR, LONGNVARCHAR;
+ // - BINARY, VARBINARY, LONGVARBINARY;
+ // - DATE, TIME, TIMESTAMP;
+ // - DATALINK;
+
+ ////////////////////////////////////////
+ // - getBytes:
+ // - BINARY, VARBINARY, LONGVARBINARY;
+
+ ////////////////////////////////////////
+ // - getDate:
+ // - CHAR, VARCHAR, LONGVARCHAR;
+ // - DATE, TIMESTAMP;
+
+ ////////////////////////////////////////
+ // - getTime:
+ // - CHAR, VARCHAR, LONGVARCHAR;
+ // - TIME, TIMESTAMP;
+
+ ////////////////////////////////////////
+ // - getTimestamp:
+ // - CHAR, VARCHAR, LONGVARCHAR;
+ // - DATE, TIME, TIMESTAMP;
+
+ ////////////////////////////////////////
+ // - getAsciiStream:
+ // - CHAR, VARCHAR, LONGVARCHAR;
+ // - BINARY, VARBINARY, LONGVARBINARY;
+ // - CLOB, NCLOB;
+
+ ////////////////////////////////////////
+ // - getBinaryStream:
+ // - BINARY, VARBINARY, LONGVARBINARY;
+
+ ////////////////////////////////////////
+ // - getCharacterStream:
+ // - CHAR, VARCHAR, LONGVARCHAR;
+ // - NCHAR, NVARCHAR, LONGNVARCHAR;
+ // - BINARY, VARBINARY, LONGVARBINARY;
+ // - CLOB, NCLOB;
+ // - SQLXML;
+
+ ////////////////////////////////////////
+ // - getNCharacterStream:
+ // - CHAR, VARCHAR, LONGVARCHAR;
+ // - NCHAR, NVARCHAR, LONGNVARCHAR;
+ // - BINARY, VARBINARY, LONGVARBINARY;
+ // - CLOB, NCLOB;
+ // - SQLXML;
+
+ ////////////////////////////////////////
+ // - getClob:
+ // - CLOB, NCLOB;
+
+ ////////////////////////////////////////
+ // - getNClob:
+ // - CLOB, NCLOB;
+
+ ////////////////////////////////////////
+ // - getBlob:
+ // - BLOB;
+
+ ////////////////////////////////////////
+ // - getArray:
+ // - ARRAY;
+
+ ////////////////////////////////////////
+ // - getRef:
+ // - REF;
+
+ ////////////////////////////////////////
+ // - getURL:
+ // - DATALINK;
+
+ ////////////////////////////////////////
+ // - getObject:
+ // - TINYINT, SMALLINT, INTEGER, BIGINT; REAL, FLOAT, DOUBLE; DECIMAL, NUMERIC;
+ // - BIT, BOOLEAN;
+ // - CHAR, VARCHAR, LONGVARCHAR;
+ // - NCHAR, NVARCHAR, LONGNVARCHAR;
+ // - BINARY, VARBINARY, LONGVARBINARY;
+ // - CLOB, NCLOB;
+ // - BLOB;
+ // - DATE, TIME, TIMESTAMP;
+ // - TIME_WITH_TIMEZONE;
+ // - TIMESTAMP_WITH_TIMEZONE;
+ // - DATALINK;
+ // - ROWID;
+ // - SQLXML;
+ // - ARRAY;
+ // - REF;
+ // - STRUCT;
+ // - JAVA_OBJECT;
+
+ ////////////////////////////////////////
+ // - getRowId:
+ // - ROWID;
+
+ ////////////////////////////////////////
+ // - getSQLXML:
+ // - SQLXML SQLXML
+
+}