/*
* Copyright 1999-2015 dangdang.com.
* <p>
* Licensed 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.
* </p>
*/
package com.dangdang.ddframe.rdb.sharding.jdbc.adapter;
import com.dangdang.ddframe.rdb.integrate.AbstractDBUnitTest;
import com.dangdang.ddframe.rdb.integrate.db.AbstractShardingDataBasesOnlyDBUnitTest;
import com.dangdang.ddframe.rdb.sharding.constants.DatabaseType;
import com.dangdang.ddframe.rdb.sharding.jdbc.ShardingConnection;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.math.BigDecimal;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Calendar;
import java.util.Collections;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
public final class ResultSetGetterAdapterTest extends AbstractShardingDataBasesOnlyDBUnitTest {
private ShardingConnection shardingConnection;
private Statement statement;
private ResultSet actual;
@Before
public void init() throws SQLException {
shardingConnection = getShardingDataSource().getConnection();
statement = shardingConnection.createStatement();
actual = statement.executeQuery("SELECT user_id AS `uid` FROM `t_order` WHERE `status` = 'init' ORDER BY `uid`");
actual.next();
}
@After
public void close() throws SQLException {
actual.close();
statement.close();
shardingConnection.close();
}
@Test
public void assertGetBooleanForColumnIndex() throws SQLException {
assertTrue(actual.getBoolean(1));
}
@Test
public void assertGetBooleanForColumnLabel() throws SQLException {
assertTrue(actual.getBoolean("uid"));
}
@Test
public void assertGetByteForColumnIndex() throws SQLException {
assertThat(actual.getByte(1), is((byte) 10));
}
@Test
public void assertGetByteForColumnLabel() throws SQLException {
assertThat(actual.getByte("uid"), is((byte) 10));
}
@Test
public void assertGetShortForColumnIndex() throws SQLException {
assertThat(actual.getShort(1), is((short) 10));
}
@Test
public void assertGetShortForColumnLabel() throws SQLException {
assertThat(actual.getShort("uid"), is((short) 10));
}
@Test
public void assertGetIntForColumnIndex() throws SQLException {
assertThat(actual.getInt(1), is(10));
}
@Test
public void assertGetIntForColumnLabel() throws SQLException {
assertThat(actual.getInt("uid"), is(10));
}
@Test
public void assertGetLongForColumnIndex() throws SQLException {
assertThat(actual.getLong(1), is(10L));
}
@Test
public void assertGetLongForColumnLabel() throws SQLException {
assertThat(actual.getLong("uid"), is(10L));
}
@Test
public void assertGetFloatForColumnIndex() throws SQLException {
assertThat(actual.getFloat(1), is(10F));
}
@Test
public void assertGetFloatForColumnLabel() throws SQLException {
assertThat(actual.getFloat("uid"), is(10F));
}
@Test
public void assertGetDoubleForColumnIndex() throws SQLException {
assertThat(actual.getDouble(1), is(10D));
}
@Test
public void assertGetDoubleForColumnLabel() throws SQLException {
assertThat(actual.getDouble("uid"), is(10D));
}
@Test
public void assertGetStringForColumnIndex() throws SQLException {
assertThat(actual.getString(1), is("10"));
}
@Test
public void assertGetStringForColumnLabel() throws SQLException {
assertThat(actual.getString("uid"), is("10"));
}
@Test
public void assertGetBigDecimalForColumnIndex() throws SQLException {
assertThat(actual.getBigDecimal(1), is(new BigDecimal("10")));
}
@Test
public void assertGetBigDecimalForColumnLabel() throws SQLException {
assertThat(actual.getBigDecimal("uid"), is(new BigDecimal("10")));
}
@SuppressWarnings("deprecation")
@Test
public void assertGetBigDecimalColumnIndexWithScale() throws SQLException {
assertThat(actual.getBigDecimal(1, 2), is(new BigDecimal("10")));
}
@SuppressWarnings("deprecation")
@Test
public void assertGetBigDecimalColumnLabelWithScale() throws SQLException {
assertThat(actual.getBigDecimal("uid", 2), is(new BigDecimal("10")));
}
@Test
public void assertGetBytesForColumnIndex() throws SQLException {
assertTrue(actual.getBytes(1).length > 0);
}
@Test
public void assertGetBytesForColumnLabel() throws SQLException {
assertTrue(actual.getBytes("uid").length > 0);
}
@Test(expected = SQLException.class)
public void assertGetDateForColumnIndex() throws SQLException {
actual.getDate(1);
}
@Test(expected = SQLException.class)
public void assertGetDateForColumnLabel() throws SQLException {
actual.getDate("uid");
}
@Test(expected = SQLException.class)
public void assertGetDateColumnIndexWithCalendar() throws SQLException {
actual.getDate(1, Calendar.getInstance());
}
@Test(expected = SQLException.class)
public void assertGetDateColumnLabelWithCalendar() throws SQLException {
actual.getDate("uid", Calendar.getInstance());
}
@Test(expected = SQLException.class)
public void assertGetTimeForColumnIndex() throws SQLException {
actual.getTime(1);
}
@Test(expected = SQLException.class)
public void assertGetTimeForColumnLabel() throws SQLException {
actual.getTime("uid");
}
@Test(expected = SQLException.class)
public void assertGetTimeColumnIndexWithCalendar() throws SQLException {
actual.getTime(1, Calendar.getInstance());
}
@Test(expected = SQLException.class)
public void assertGetTimeColumnLabelWithCalendar() throws SQLException {
actual.getTime("uid", Calendar.getInstance());
}
@Test
public void assertGetTimestampForColumnIndex() throws SQLException {
if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
try {
actual.getTimestamp(1);
} catch (final SQLException ex) {
assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
}
} else {
assertTrue(actual.getTimestamp(1).getTime() > 0);
}
}
@Test
public void assertGetTimestampForColumnLabel() throws SQLException {
if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
try {
actual.getTimestamp("uid");
} catch (final SQLException ex) {
assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
}
} else {
assertTrue(actual.getTimestamp("uid").getTime() > 0);
}
}
@Test
public void assertGetTimestampColumnIndexWithCalendar() throws SQLException {
if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
try {
actual.getTimestamp(1, Calendar.getInstance());
} catch (final SQLException ex) {
assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
}
} else {
assertTrue(actual.getTimestamp(1, Calendar.getInstance()).getTime() > 0);
}
}
@Test
public void assertGetTimestampColumnLabelWithCalendar() throws SQLException {
if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
try {
actual.getTimestamp("uid", Calendar.getInstance());
} catch (final SQLException ex) {
assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
}
} else {
assertTrue(actual.getTimestamp("uid", Calendar.getInstance()).getTime() > 0);
}
}
@Test
public void assertGetAsciiStreamForColumnIndex() throws SQLException, IOException {
byte[] b = new byte[1];
actual.getAsciiStream(1).read(b);
assertThat(new String(b), is("1"));
}
@Test
public void assertGetAsciiStreamForColumnLabel() throws SQLException, IOException {
byte[] b = new byte[1];
actual.getAsciiStream("uid").read(b);
assertThat(new String(b), is("1"));
}
@SuppressWarnings("deprecation")
@Test
public void assertGetUnicodeStreamForColumnIndex() throws SQLException, IOException {
byte[] b = new byte[1];
if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
try {
actual.getUnicodeStream(1).read(b);
} catch (final SQLException ignore) {
}
} else {
actual.getUnicodeStream(1).read(b);
assertThat(new String(b), is("1"));
}
}
@SuppressWarnings("deprecation")
@Test
public void assertGetUnicodeStreamForColumnLabel() throws SQLException, IOException {
byte[] b = new byte[1];
if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
try {
actual.getUnicodeStream("uid").read(b);
} catch (final SQLException ignore) {
}
} else {
actual.getUnicodeStream("uid").read(b);
assertThat(new String(b), is("1"));
}
}
@Test
public void assertGetBinaryStreamForColumnIndex() throws SQLException, IOException {
assertTrue(actual.getBinaryStream(1).read() != -1);
}
@Test
public void assertGetBinaryStreamForColumnLabel() throws SQLException, IOException {
assertTrue(actual.getBinaryStream("uid").read() != -1);
}
@Test
public void assertGetCharacterStreamForColumnIndex() throws SQLException, IOException {
char[] c = new char[1];
actual.getCharacterStream(1).read(c);
assertThat(c[0], is('1'));
}
@Test
public void assertGetCharacterStreamForColumnLabel() throws SQLException, IOException {
char[] c = new char[1];
actual.getCharacterStream("uid").read(c);
assertThat(c[0], is('1'));
}
@Test
public void assertGetBlobForColumnIndex() throws SQLException {
assertTrue(actual.getBlob(1).length() > 0);
}
@Test
public void assertGetBlobForColumnLabel() throws SQLException {
assertTrue(actual.getBlob("uid").length() > 0);
}
@Test
public void assertGetClobForColumnIndex() throws SQLException {
assertThat(actual.getClob(1).getSubString(1, 2), is("10"));
}
@Test
public void assertGetClobForColumnLabel() throws SQLException {
assertThat(actual.getClob("uid").getSubString(1, 2), is("10"));
}
@Test(expected = SQLException.class)
public void assertGetURLForColumnIndex() throws SQLException {
actual.getURL(1);
}
@Test(expected = SQLException.class)
public void assertGetURLForColumnLabel() throws SQLException {
actual.getURL("uid");
}
@Test
public void assertGetSQLXMLForColumnIndex() throws SQLException {
if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
try {
actual.getSQLXML(1);
} catch (final SQLException ignore) {
}
} else {
assertThat(actual.getSQLXML(1).getString(), is("10"));
}
}
@Test
public void assertGetSQLXMLForColumnLabel() throws SQLException {
if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
try {
actual.getSQLXML("uid");
} catch (final SQLException ignore) {
}
} else {
assertThat(actual.getSQLXML("uid").getString(), is("10"));
}
}
@Test
public void assertGetObjectForColumnIndex() throws SQLException {
assertThat(actual.getObject(1).toString(), is("10"));
}
@Test
public void assertGetObjectForColumnLabel() throws SQLException {
assertThat(actual.getObject("uid").toString(), is("10"));
}
@Test
public void assertGetObjectForColumnIndexWithMap() throws SQLException {
if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
try {
actual.getObject(1, Collections.<String, Class<?>>emptyMap());
} catch (final SQLException ignore) {
}
} else {
assertThat(actual.getObject(1, Collections.<String, Class<?>>emptyMap()).toString(), is("10"));
}
}
@Test
public void assertGetObjectForColumnLabelWithMap() throws SQLException {
if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
try {
actual.getObject("uid", Collections.<String, Class<?>>emptyMap());
} catch (final SQLException ignore) {
}
} else {
assertThat(actual.getObject("uid", Collections.<String, Class<?>>emptyMap()).toString(), is("10"));
}
}
}