/*
* Copyright (C) 2007 The Android Open Source Project
*
* 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.
*/
package tests.sql;
import dalvik.annotation.KnownFailure;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import java.io.IOException;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
@TestTargetClass(ResultSetMetaData.class)
public class ResultSetMetaDataTest extends SQLTest {
ResultSetMetaData rsmd = null;
Statement st = null;
ResultSet rs = null;
@Override
public void setUp() throws Exception {
super.setUp();
try {
conn.setAutoCommit(false);
assertFalse(conn.getAutoCommit());
String query = "select * from zoo";
st = conn.createStatement();
st.execute(query);
rs = st.getResultSet();
rsmd = rs.getMetaData();
} catch (SQLException e) {
fail("Couldn't get ResultSetMetaData object");
}
}
@Override
public void tearDown() {
try {
rs.close();
st.close();
} catch (SQLException e) {
fail("Couldn't close Statement object");
}
super.tearDown();
}
/**
* @test java.sql.ResultSetMetaData#getCatalogName(int column)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Catalog not supported.",
method = "getCatalogName",
args = {int.class}
)
@KnownFailure("not supported")
public void testGetCatalogName() throws SQLException {
try {
assertNotNull(rsmd.getCatalogName(1));
} catch (SQLException e) {
fail("SQLException is thrown: " + e.getMessage());
}
try {
conn.close();
rsmd.getCatalogName(0);
fail("Exception expected");
} catch (SQLException e) {
//ok
}
}
/**
* @test java.sql.ResultSetMetaData#getColumnClassName(int column)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getColumnClassName",
args = {int.class}
)
public void testGetColumnClassName() {
try {
assertNotNull(rsmd);
assertEquals(Short.class.getName(), rsmd.getColumnClassName(1));
assertEquals(String.class.getName(), rsmd.getColumnClassName(2));
assertEquals(String.class.getName(), rsmd.getColumnClassName(3));
} catch (SQLException e) {
fail("SQLException is thrown: " + e.getMessage());
}
try {
String name = rsmd.getColumnClassName(0);
assertNull(name);
} catch (SQLException e) {
fail("SQLException is thrown");
}
try {
String name = rsmd.getColumnClassName(4);
assertNull(name);
} catch (SQLException e) {
fail("SQLException is thrown");
}
}
/**
* @test java.sql.ResultSetMetaData#getColumnCount()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getColumnCount",
args = {}
)
@KnownFailure("SQLException checking test fails")
public void testGetColumnCount() {
try {
assertEquals(3, rsmd.getColumnCount());
} catch (SQLException e) {
fail("SQLException is thrown: " + e.getMessage());
}
try {
rs.close();
rsmd.getColumnCount();
fail("Exception expected");
} catch (SQLException e) {
//ok
}
}
/**
* @test java.sql.ResultSetMetaData#getColumnLabel(int column)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getColumnLabel",
args = {int.class}
)
@KnownFailure("Column label has format TABLE.COLUMN expected: COLUMN")
public void testGetColumnLabel() {
String[] labels = { "id", "name", "family" };
try {
for (int i = 0; i < rsmd.getColumnCount(); i++) {
String label = rsmd.getColumnLabel(i + 1);
assertTrue("expected "+labels[i] + "got "+label,labels[i].contains(label));
}
} catch (SQLException e) {
fail("SQLException is thrown: " + e.getMessage());
}
try {
String label = rsmd.getColumnLabel(0);
fail("SQLException expected");
} catch (SQLException e) {
//ok
}
try {
String label = rsmd.getColumnLabel(5);
fail("SQLException expected");
} catch (SQLException e) {
//ok
}
}
/**
* @test java.sql.ResultSetMetaData#getColumnName(int column)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getColumnName",
args = {int.class}
)
@KnownFailure("Column label has format TABLE.COLUMN expected: COLUMN")
public void testGetColumnName() {
String[] labels = { "id", "name", "family" };
try {
for (int i = 0; i < rsmd.getColumnCount(); i++) {
String name = rsmd.getColumnName(i + 1);
assertEquals(labels[i], name);
}
} catch (SQLException e) {
fail("SQLException is thrown: " + e.getMessage());
}
try {
String label = rsmd.getColumnName(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
//ok
}
try {
String label = rsmd.getColumnName(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @test java.sql.ResultSetMetaData#getColumnType(int column)
*
* for extensive tests see: ResultSetGetterTest.testGetMetaData
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Not all types supported. More type checking done in ResultSetGetterTest.testGetMetaData",
method = "getColumnType",
args = {int.class}
)
public void testGetColumnType() {
int[] types = { Types.SMALLINT, Types.VARCHAR, Types.VARCHAR};
try {
for (int i = 0; i < rsmd.getColumnCount(); i++) {
int type = rsmd.getColumnType(i + 1);
assertEquals(types[i], type);
}
} catch (SQLException e) {
fail("SQLException is thrown: " + e.getMessage());
}
try {
rsmd.getColumnType(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.getColumnType(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
}
/**
* @test java.sql.ResultSetMetaData#getColumnTypeName(int column)
*
* for extensive tests see: ResultSetGetterTest.testGetMetaData
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "not all types supported: see ResultSetGetterTests.",
method = "getColumnTypeName",
args = {int.class}
)
public void testGetColumnTypeName() {
try {
assertTrue("smallint".equalsIgnoreCase(rsmd.getColumnTypeName(1)));
assertTrue("varchar".equalsIgnoreCase(rsmd.getColumnTypeName(2)));
assertTrue("varchar".equalsIgnoreCase(rsmd.getColumnTypeName(3)));
} catch (SQLException e) {
fail("SQLException is thrown: " + e.getMessage());
}
try {
rsmd.getColumnTypeName(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.getColumnTypeName(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
}
/**
* @throws SQLException
* @test java.sql.ResultSetMetaData#getTableName(int column)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getTableName",
args = {int.class}
)
@KnownFailure("For int = 0, exception expected")
public void testGetTableName() throws SQLException {
try {
assertEquals("zoo", rsmd.getTableName(1));
} catch (SQLException e) {
fail("SQLException is thrown: " + e.getMessage());
}
Statement st1 = null;
ResultSet rs1 = null;
try {
String create = "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));";
String insert1 = "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');";
String insert2 = "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');";
String query = "select name, animal_id from hutch, zoo where zoo.id = 1" ;
st1 = conn.createStatement();
st1.executeUpdate(create);
st1.executeUpdate(insert1);
st1.executeUpdate(insert2);
rs1 = st1.executeQuery(query);
assertNotNull(rs1);
ResultSetMetaData rsmd1 = rs1.getMetaData();
assertEquals("zoo", rsmd1.getTableName(1));
assertEquals("hutch", rsmd1.getTableName(2));
} catch (SQLException e) {
fail("SQLException is thrown: " + e.getMessage());
} finally {
try {
if (rs1 != null) rs1.close();
if (st1 != null) {
st1.executeUpdate("drop table if exists hutch");
st1.close();
}
} catch (SQLException sqle) {
}
}
//Exception Text
try {
String name = rsmd.getTableName(0);
fail("SQLException Expected");
} catch (SQLException e) {
// ok
}
}
/**
* @test {@link java.sql.ResultSetMetaData#getPrecision(int column)}
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Tests fails: always returns 0, exception tests fail ,failing statements commented out",
method = "getPrecision",
args = {int.class}
)
@KnownFailure("not supported")
public void testGetPrecision() throws SQLException {
Statement st2 = null;
Statement st3 = null;
ResultSetMetaData rsmd2 = null;
try {
int precisionNum = 10;
int scale = 3;
int precicisionReal = 10;
String createTable = "create table DecimalNumbers ( valueDouble DOUBLE,"+
"valueFloat FLOAT , scaleTest NUMERIC("+precisionNum+","+scale+"),"+
" valueReal REAL("+precicisionReal+") );";
String insert = "insert into DecimalNumbers values (1.5, 20.55, 30.666, 100000);";
String select = "select * from DecimalNumbers;";
st2 = conn.createStatement();
st2.executeUpdate(createTable);
st2.executeUpdate(insert);
st2.close();
st3 = conn.createStatement();
rs = st3.executeQuery(select);
assertTrue(rs.next());
rsmd2 = rs.getMetaData();
assertNotNull(rsmd2);
assertEquals(precicisionReal, rsmd2.getPrecision(4));
assertEquals(precisionNum,rsmd2.getPrecision(3));
assertTrue(rsmd2.getPrecision(2) > 0);
assertTrue(rsmd2.getPrecision(1) > 0);
// non numeric field
try {
rsmd.getPrecision(3);
} catch (SQLException e1) {
System.out.println("ResultSetMetaDataTest.testGetPrecision()"+e1.getMessage());
e1.printStackTrace();
}
try {
rsmd.getPrecision(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.getPrecision(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rs.close();
rsmd.getPrecision(1);
fail("Exception expected");
} catch (SQLException e) {
//ok
}
} finally {
if (st2 != null) st2.close();
if (st3 != null) st3.close();
}
}
/**
* @test {@link java.sql.ResultSetMetaData#getScale(int column)}
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Tests fail: always returns 0, exception tests fail"+
" no positive test case for black-box test possible: no default"+
" value indicated",
method = "getScale",
args = {int.class}
)
@KnownFailure("Not supported")
public void testGetScale() throws SQLException {
try {
int scale = 3;
String createTable = "create table DecimalNumbers ( valueDouble DOUBLE,"+
"valueFloat FLOAT , scaleTest NUMERIC(10,"+scale+") );";
String insert = "insert into DecimalNumbers values (1.5, 20.55, 30.666);";
String select = "select * from DecimalNumbers;";
Statement st = conn.createStatement();
st.executeUpdate(createTable);
st.executeUpdate(insert);
rs = st.executeQuery(select);
ResultSetMetaData rsmd2 = rs.getMetaData();
assertNotNull(rsmd2);
assertEquals(scale,rsmd2.getScale(3));
assertTrue(rsmd2.getScale(1) > 0);
assertTrue(rsmd2.getScale(2) > 0);
try {
rsmd.getScale(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.getScale(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
conn.close();
rsmd.getScale(1);
fail("Exception expected");
} catch (SQLException e) {
//ok
}
} finally {
st.cancel();
}
}
/**
* @test {@link java.sql.ResultSetMetaData#getSchemaName(int column)}
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Tests fail: always returns null. Feature only partially implemented. Missing: positive test.",
method = "getSchemaName",
args = {int.class}
)
@KnownFailure("not supported")
public void testGetSchema() {
try {
assertNull("Functionality is now supported. Change test",rsmd.getSchemaName(2));
} catch (SQLException e1) {
fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
e1.printStackTrace();
}
try {
rsmd.getSchemaName(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.getSchemaName(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
conn.close();
rsmd.getSchemaName(2);
fail("Exception expected");
} catch (SQLException e) {
//ok
}
}
/**
* @test {@link java.sql.ResultSetMetaData#isAutoIncrement(int column)}
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Tests fail: always returns false, failing statements commented out. Feature only partially implemented.Missing: Test positive case",
method = "isAutoIncrement",
args = {int.class}
)
@KnownFailure("not supported")
public void testisAutoIncrement() {
try {
assertFalse(rsmd.isAutoIncrement(1));
} catch (SQLException e1) {
fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
e1.printStackTrace();
}
/*
// Exception testing
try {
rsmd.isAutoIncrement(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.isAutoIncrement(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
*/
try {
conn.close();
rsmd.getSchemaName(2);
fail("Exception expected");
} catch (SQLException e) {
//ok
}
}
/**
* @test {@link java.sql.ResultSetMetaData#isCaseSensitive(int column)}
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Tests fail: always returns false. Exception tests fail, failing statements commented out. Feature only partially implemented.",
method = "isCaseSensitive",
args = {int.class}
)
@KnownFailure("not supported")
public void testIsCaseSensitive() {
try {
assertFalse(rsmd.isCaseSensitive(1));
assertFalse(rsmd.isCaseSensitive(2));
assertFalse(rsmd.isCaseSensitive(3));
} catch (SQLException e1) {
fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
e1.printStackTrace();
}
/*
// Exception testing
try {
rsmd.isCaseSensitive(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.isCaseSensitive(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
*/
try {
conn.close();
rsmd.isCaseSensitive(1);
fail("Exception expected");
} catch (SQLException e) {
//ok
}
}
/**
* @test {@link java.sql.ResultSetMetaData#isCurrency(int column)}
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Tests fail: always returns false. Exceptions and tests non Numeric fields fail, failing statements commented out. Feature only partially implemented. May be an optional feature.",
method = "isCurrency",
args = {int.class}
)
@KnownFailure("not supported")
public void testIsCurrency() {
try {
assertFalse(rsmd.isCurrency(1));
} catch (SQLException e1) {
fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
e1.printStackTrace();
}
// Exception testing
try {
rsmd.isCurrency(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.isCurrency(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rs.close();
rsmd.isCurrency(1);
fail("Exception expected");
} catch (SQLException e) {
//ok
}
}
/**
* @test {@link java.sql.ResultSetMetaData#isDefinitelyWritable(int column)}
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Tests fail: always returns true. Exceptions fail, Feature only partially implemented.",
method = "isDefinitelyWritable",
args = {int.class}
)
@KnownFailure("not supported")
public void testIsDefinitlyWritable() {
try {
assertTrue(rsmd.isDefinitelyWritable(1));
} catch (SQLException e1) {
fail("ResultSetMetaDataTest.testisDefinitelyWritable()"
+ e1.getMessage());
e1.printStackTrace();
}
// Exception testing
try {
rsmd.isDefinitelyWritable(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.isDefinitelyWritable(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
}
/**
* @test {@link java.sql.ResultSetMetaData#isNullable(int column)}
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Tests fail: always returns ResultSetMetaData.columnNullableUnknown. Exceptions fail, failing statements commented out. Feature only partially implemented. May be an optional feature.",
method = "isNullable",
args = {int.class}
)
@KnownFailure("not supported")
public void testIsNullable() {
try {
assertEquals(ResultSetMetaData.columnNullable, rsmd
.isNullable(1));
assertEquals(ResultSetMetaData.columnNullable, rsmd
.isNullable(2));
assertEquals(ResultSetMetaData.columnNullable, rsmd
.isNullable(3));
} catch (SQLException e1) {
fail("ResultSetMetaDataTest.isNullable()" + e1.getMessage());
e1.printStackTrace();
}
/*
// Exception testing
try {
rsmd.isNullable(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.isNullable(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
*/
}
/**
* @test {@link java.sql.ResultSetMetaData#isReadOnly(int column)}
*/
@TestTargetNew(
level = TestLevel.NOT_FEASIBLE,
notes = "Cannot know from blackbox test if readonly or writable. Exceptions fail, Feature only partially implemented.",
method = "isReadOnly",
args = {int.class}
)
@KnownFailure("not supported")
public void testIsReadOnly() {
try {
assertFalse(rsmd.isReadOnly(1));
} catch (SQLException e1) {
fail("ResultSetMetaDataTest.isReadOnly" + e1.getMessage());
e1.printStackTrace();
}
// Exception testing
try {
rsmd.isReadOnly(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
}
/**
* @test {@link java.sql.ResultSetMetaData#isSearchable(int column)}
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Tests fail: always returns false. Exceptions fail, Feature only partially implemented. Missing: test for searchable field.",
method = "isSearchable",
args = {int.class}
)
@KnownFailure("not supported")
public void testIsSearchable() {
try {
assertTrue(rsmd.isSearchable(1));
assertTrue(rsmd.isSearchable(2));
assertTrue(rsmd.isSearchable(3));
} catch (SQLException e1) {
fail("ResultSetMetaDataTest.isReadOnly" + e1.getMessage());
e1.printStackTrace();
}
// Exception testing
try {
rsmd.isSearchable(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
}
/**
* @test {@link java.sql.ResultSetMetaData#isSigned(int column)}
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Tests fail: always returns false. Exceptions and tests on non numeric fields fail, Feature only partially implemented. Missing: test positive result.",
method = "isSigned",
args = {int.class}
)
@KnownFailure("not supported")
public void testIsSigned() {
try {
assertFalse(rsmd.isSigned(1));
} catch (SQLException e1) {
fail("ResultSetMetaDataTest.isSigned" + e1.getMessage());
e1.printStackTrace();
}
// Exception testing
try {
rsmd.isSigned(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
}
/**
* @test {@link java.sql.ResultSetMetaData#isWritable(int column)}
*/
@TestTargetNew(
level = TestLevel.NOT_FEASIBLE,
notes = "Analaguous to is Readonly. Exceptions and tests on non numeric fields fail, failing statements commented out. Feature only partially implemented.",
method = "isWritable",
args = {int.class}
)
@KnownFailure("not supported")
public void testIsWritable() {
try {
assertTrue(rsmd.isWritable(1));
assertTrue(rsmd.isWritable(2));
assertTrue(rsmd.isWritable(3));
} catch (SQLException e1) {
fail("ResultSetMetaDataTest.isWritable" + e1.getMessage());
e1.printStackTrace();
}
// Exception testing
try {
rsmd.isWritable(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
}
/**
* @test {@link java.sql.ResultSetMetaData#getColumnDisplaySize(int Column)}
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Tests fail. always returns 0. Missing case where display"+
" size greater than 0",
method = "getColumnDisplaySize",
args = {int.class}
)
@KnownFailure("not supported")
public void testGetColumnDisplaySize() {
try {
for (int i = 0; i < rsmd.getColumnCount(); i++) {
int size = rsmd.getColumnDisplaySize(i + 1);
assertTrue(size > 0);
}
} catch (SQLException e) {
fail("SQLException is thrown: " + e.getMessage());
}
// Exception testing
try {
rsmd.getColumnDisplaySize(0);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
try {
rsmd.getColumnDisplaySize(5);
fail("SQLException is not thrown");
} catch (SQLException e) {
// expected
}
}
}