| /* |
| * Copyright (C) 2007 Google Inc. |
| * |
| * 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.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargetClass; |
| |
| |
| import java.io.IOException; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.sql.DatabaseMetaData; |
| import java.sql.Date; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.ResultSetMetaData; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| import java.sql.Time; |
| import java.sql.Timestamp; |
| import java.util.Arrays; |
| import java.util.Calendar; |
| import java.util.GregorianCalendar; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.ListIterator; |
| |
| /** |
| * Tests based on |
| * <a href="http://java.sun.com/products/jdbc/download.html">JDBC 1.0 API spec |
| * </a> Table 1.0 |
| */ |
| @TestTargetClass(ResultSet.class) |
| public class ResultSetGetterTests extends SQLTest { |
| |
| String queryAllSelect = "select * from type"; |
| |
| ResultSet res = null; |
| |
| Statement st = null; |
| |
| // Judgement concerning support is based on the result of ResultSet.getOject |
| // and Table 1 of JDBC 1.0 spec. |
| static boolean booleanSupported = false; |
| static boolean blobSupported = false; |
| static boolean bigIntSupported = false; |
| static boolean smallIntSupported = false; |
| static boolean mediumIntSupported = false; |
| static boolean realSupported = false; |
| static boolean floatSupported = false; |
| static boolean dateSupported = false; |
| static boolean timeSupported = false; |
| static boolean timeStampSupported = false; |
| static boolean dateTimeSupported = false; |
| static boolean urlSupported= false; |
| static boolean tinyIntSupported = false; |
| static boolean decimalSupported = false; |
| static boolean numericSupported = false; |
| |
| static List<String> colNames = Arrays.asList("BoolVal", "IntVal", "LongVal", |
| "Bint", "Tint", "Sint", "Mint", "IntegerVal", "RealVal", |
| "DoubleVal", "FloatVal", "DecVal", "NumVal", "charStr", |
| "dateVal", "timeVal", "TS", "DT", "TBlob", "BlobVal", "MBlob", |
| "LBlob", "TText", "TextVal", "MText", "LText", "MaxLongVal", |
| "MinLongVal", "validURL", "invalidURL"); |
| |
| static List<String> values = Arrays.asList("1", "-1", "22", "2", "33", |
| "3","1","2","3.9","23.2","33.3","44", |
| "5", "test string", "1799-05-26", "12:35:45", "2007-10-09 14:28:02.0", |
| "1221-09-22 10:11:55","1","2","3","4","Test text message tiny", |
| "Test text", "Test text message medium", |
| "Test text message long"); |
| |
| static boolean[] supported = new boolean[]{ |
| booleanSupported, |
| true, |
| true, |
| bigIntSupported, |
| tinyIntSupported, |
| smallIntSupported, |
| mediumIntSupported, |
| true, |
| realSupported, |
| true, |
| floatSupported, |
| decimalSupported, |
| numericSupported, |
| true, |
| dateSupported, |
| timeSupported, |
| timeStampSupported, |
| dateTimeSupported, |
| blobSupported, |
| blobSupported, |
| blobSupported, |
| blobSupported, |
| true, |
| true, |
| true, |
| true, |
| bigIntSupported, |
| bigIntSupported, |
| urlSupported, |
| urlSupported |
| }; |
| |
| // Not supported: BIT,VARBINARY, LONGVARBINARY, BINARY, VARCHAR, LONGVARCHAR |
| static Class[] typeMap = new Class[]{ |
| java.lang.String.class, // |
| java.lang.Integer.class,//Types.INTEGER, |
| java.lang.Integer.class, //Types.LONG, not a JDBC 1.0 type |
| java.lang.Long.class, // Types.BIGINT, |
| java.lang.Byte.class, // Types.TINYINT, |
| java.lang.Short.class, // Types.SMALLINT, |
| java.lang.Integer.class, //Types.MEDIUMINT, , not a JDBC 1.0 type |
| java.lang.Integer.class, // Types.Integer |
| java.lang.Float.class, // Types.REAL, |
| java.lang.Double.class, // Types.FLOAT, |
| java.lang.Double.class, // Types.DOUBLE, |
| java.math.BigDecimal.class, // Types.DECIMAL, |
| java.math.BigDecimal.class, // Types.NUMERIC, |
| java.lang.String.class, // Types.CHAR |
| java.sql.Date.class, // Types.DATE, |
| java.sql.Time.class, // Types.TIME, |
| java.sql.Timestamp.class, // Types.TIMESTAMP, |
| java.sql.Date.class, // types datetime, not a JDBC 1.0 type |
| java.sql.Blob.class, // Types.BLOB, not a JDBC 1.0 type |
| java.sql.Blob.class, // Types.BLOB, not a JDBC 1.0 type |
| java.sql.Blob.class, // Types.BLOB, not a JDBC 1.0 type |
| java.sql.Blob.class, // Types.BLOB, not a JDBC 1.0 type |
| java.lang.String.class, // not a JDBC 1.0 type |
| java.lang.String.class, // not a JDBC 1.0 type |
| java.lang.String.class, // not a JDBC 1.0 type |
| java.lang.String.class, // not a JDBC 1.0 type |
| java.lang.Long.class, // Types.BIGINT, |
| java.lang.Long.class, // Types.BIGINT, |
| java.net.URL.class, // not a JDBC 1.0 type |
| java.net.URL.class // not a JDBC 1.0 type |
| |
| |
| }; |
| |
| // first inserted row : actual values |
| // second inserted row: null values |
| String[] queries = { |
| "create table type (" + |
| |
| " BoolVal BOOLEAN," + " IntVal INT," + " LongVal LONG," |
| + " Bint BIGINT," + " Tint TINYINT," + " Sint SMALLINT," |
| + " Mint MEDIUMINT, " + |
| |
| " IntegerVal INTEGER, " + " RealVal REAL, " |
| + " DoubleVal DOUBLE, " + " FloatVal FLOAT, " |
| + " DecVal DECIMAL, " + |
| |
| " NumVal NUMERIC, " + " charStr CHAR(20), " |
| + " dateVal DATE, " + " timeVal TIME, " + " TS TIMESTAMP, " |
| + |
| |
| " DT DATETIME, " + " TBlob TINYBLOB, " + " BlobVal BLOB, " |
| + " MBlob MEDIUMBLOB, " + " LBlob LONGBLOB, " + |
| |
| " TText TINYTEXT, " + " TextVal TEXT, " |
| + " MText MEDIUMTEXT, " + " LText LONGTEXT, " + |
| |
| " MaxLongVal BIGINT, MinLongVal BIGINT, "+ |
| |
| " validURL URL, invalidURL URL "+ |
| |
| ");" |
| , |
| |
| "insert into type (BoolVal, IntVal, LongVal, Bint, Tint, Sint, Mint," |
| + "IntegerVal, RealVal, DoubleVal, FloatVal, DecVal," |
| + "NumVal, charStr, dateVal, timeVal, TS," |
| + "DT, TBlob, BlobVal, MBlob, LBlob," |
| + "TText, TextVal, MText, LText, MaxLongVal, MinLongVal," |
| + " validURL, invalidURL" |
| + ") " |
| + "values (1, -1, 22, 2, 33," |
| + "3, 1, 2, 3.9, 23.2, 33.3, 44," |
| + "5, 'test string', '1799-05-26', '12:35:45', '2007-10-09 14:28:02.0'," |
| + "'1221-09-22 10:11:55', 1, 2, 3, 4," |
| + "'Test text message tiny', 'Test text'," |
| + " 'Test text message medium', 'Test text message long', " |
| + Long.MAX_VALUE+", "+Long.MIN_VALUE+", " |
| + "'http://www.android.com', 'helloWorld' "+ |
| ");" |
| , |
| |
| "insert into type (BoolVal, IntVal, LongVal, Bint, Tint, Sint, Mint," |
| + "IntegerVal, RealVal, DoubleVal, FloatVal, DecVal," |
| + "NumVal, charStr, dateVal, timeVal, TS," |
| + "DT, TBlob, BlobVal, MBlob, LBlob," |
| + "TText, TextVal, MText, LText, MaxLongVal, MinLongVal," |
| +" validURL, invalidURL" |
| + ") " |
| + "values (null, null, null, null, null," |
| + "null, null, null, null, null, null, null," |
| + "null, null, null, null, null," |
| + "null, null, null, null, null," |
| + "null, null, null, null,null, null, null, null);" |
| }; |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| try { |
| conn.setAutoCommit(false); |
| st = conn.createStatement(); |
| for (int i = 0; i < queries.length; i++) { |
| st.execute(queries[i]); |
| } |
| res = st.executeQuery(queryAllSelect); |
| assertTrue(res.next()); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } |
| } |
| |
| public void tearDown() { |
| try { |
| st.execute("drop table if exists type"); |
| st.close(); |
| res.close(); |
| } catch (SQLException e) { |
| fail("SQLException is thrown "+e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| res.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| super.tearDown(); |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getBytes(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Exception testing", |
| method = "getBytes", |
| args = {int.class} |
| ) |
| public void testGetBytesInt() { |
| int i = 1; |
| |
| |
| // null value |
| try { |
| i = 1; |
| res.next(); |
| for (String t : values) { |
| assertNull(res.getBytes(i)); |
| i++; |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.close(); |
| res.getBytes(24); |
| fail("Should get Exception"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getBytes(int)}. |
| * @throws SQLException |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "VARBINARY value", |
| method = "getBytes", |
| args = {int.class} |
| ) |
| @KnownFailure("last assertion fails: invalid conversion. Test passes on RI") |
| public void testGetBytesIntVarbinary() throws SQLException { |
| |
| Statement st = null; |
| Statement stQuery = null; |
| PreparedStatement stPrep = null; |
| ResultSet res = null; |
| |
| // setup |
| try { |
| String testString = "HelloWorld"; |
| st = conn.createStatement(); |
| st.executeUpdate("create table testBinary (VARBINARY value);"); |
| stPrep = conn |
| .prepareStatement("insert into testBinary values (?);"); |
| stPrep.setBytes(1, testString.getBytes()); |
| stPrep.execute(); |
| |
| stQuery = conn.createStatement(); |
| res = stQuery.executeQuery("select * from testBinary"); |
| try { |
| assertTrue(res.next()); |
| byte[] output = res.getBytes(1); |
| String helloTest = new String(output); |
| assertNotNull(helloTest); |
| assertEquals(testString, helloTest); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } finally { |
| if (res != null) res.close(); |
| if (stPrep != null) stPrep.close(); |
| if (st != null) st.close(); |
| if (stQuery != null) stQuery.close(); |
| } |
| |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getBytes(int)}. |
| * @throws SQLException |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "BINARY value", |
| method = "getBytes", |
| args = {int.class} |
| ) |
| @KnownFailure("last assertion fails: invalid conversion. Test passes on RI") |
| public void testGetBytesIntBinary() throws SQLException { |
| |
| Statement st = null; |
| Statement stQuery = null; |
| PreparedStatement stPrep = null; |
| ResultSet res = null; |
| |
| |
| // setup |
| |
| String testString = "HelloWorld"; |
| st = conn.createStatement(); |
| st.executeUpdate("create table testBinary (BINARY value);"); |
| stPrep = conn.prepareStatement("insert into testBinary values (?);"); |
| stPrep.setBytes(1, testString.getBytes()); |
| stPrep.execute(); |
| try { |
| stQuery = conn.createStatement(); |
| res = stQuery.executeQuery("select * from testBinary"); |
| try { |
| assertTrue(res.next()); |
| byte[] output = res.getBytes(1); |
| String helloTest = new String(output); |
| assertNotNull(helloTest); |
| assertEquals(testString, helloTest); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } finally { |
| if (res != null) res.close(); |
| if (stPrep != null) stPrep.close(); |
| if (st != null) st.close(); |
| if (stQuery != null) stQuery.close(); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getBytes(String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Exception testing", |
| method = "getBytes", |
| args = {String.class} |
| ) |
| public void testGetBytesString() { |
| int i = 1; |
| |
| // null value |
| try { |
| |
| res.next(); |
| for (String t : colNames) { |
| assertNull(res.getBytes(t)); |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.close(); |
| res.getBytes(colNames.get(24)); |
| fail("Should get Exception"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getBytes(int)}. |
| * @throws SQLException |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "VARBINARY value", |
| method = "getBytes", |
| args = {String.class} |
| ) |
| @KnownFailure("last assertion fails: invalid conversion. Test passes on RI") |
| public void testGetBytesStringVarbinary() throws SQLException { |
| |
| Statement st = null; |
| Statement stQuery = null; |
| PreparedStatement stPrep = null; |
| ResultSet res = null; |
| |
| // setup |
| try { |
| String testString = "HelloWorld"; |
| st = conn.createStatement(); |
| st.executeUpdate("create table testBinary (VARBINARY value);"); |
| stPrep = conn |
| .prepareStatement("insert into testBinary values (?);"); |
| stPrep.setBytes(1, testString.getBytes()); |
| stPrep.execute(); |
| |
| stQuery = conn.createStatement(); |
| res = stQuery.executeQuery("select value from testBinary"); |
| try { |
| assertTrue(res.next()); |
| byte[] output = res.getBytes("value"); |
| String helloTest = new String(output); |
| assertNotNull(helloTest); |
| assertEquals(testString, helloTest); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } finally { |
| if (res != null) res.close(); |
| if (stPrep != null) stPrep.close(); |
| if (st != null) st.close(); |
| if (stQuery != null) stQuery.close(); |
| } |
| |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getBytes(int)}. |
| * @throws SQLException |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "BINARY value", |
| method = "getBytes", |
| args = {String.class} |
| ) |
| @KnownFailure("last assertion fails: invalid conversion. Test passes on RI") |
| public void testGetBytesStringBinary() throws SQLException { |
| |
| Statement st = null; |
| Statement stQuery = null; |
| PreparedStatement stPrep = null; |
| ResultSet res = null; |
| |
| |
| // setup |
| |
| String testString = "HelloWorld"; |
| st = conn.createStatement(); |
| st.executeUpdate("create table testBinary (BINARY value);"); |
| stPrep = conn.prepareStatement("insert into testBinary values (?);"); |
| stPrep.setBytes(1, testString.getBytes()); |
| stPrep.execute(); |
| try { |
| stQuery = conn.createStatement(); |
| res = stQuery.executeQuery("select value from testBinary"); |
| try { |
| assertTrue(res.next()); |
| byte[] output = res.getBytes("value"); |
| String helloTest = new String(output); |
| assertNotNull(helloTest); |
| assertEquals(testString, helloTest); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } finally { |
| if (res != null) res.close(); |
| if (stPrep != null) stPrep.close(); |
| if (st != null) st.close(); |
| if (stQuery != null) stQuery.close(); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getConcurrency()}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Not fully supported: CONCUR_UPDATABLE not supported", |
| method = "getConcurrency", |
| args = {} |
| ) |
| public void testGetConcurrency() { |
| try { |
| assertEquals(ResultSet.CONCUR_READ_ONLY, res.getConcurrency()); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getDate(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getDate", |
| args = {int.class} |
| ) |
| public void testGetDateInt() { |
| try { |
| |
| GregorianCalendar testCal = new GregorianCalendar(1799, Calendar.MAY, 26, 0, 0); |
| Date input = new Date(testCal.getTimeInMillis()); |
| Date d = res.getDate(15); |
| assertEquals(input.toString(),"1799-05-26"); |
| assertEquals(input,d); |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| try { |
| Date d = res.getDate(500); |
| fail("Should get exception"); |
| } catch (SQLException e) { |
| //ok |
| } catch (Exception e) { |
| fail("Got unspecified Exception "+ e.getMessage()); |
| } |
| |
| // null value |
| try { |
| assertTrue(res.next()); |
| Date d = res.getDate(15); |
| assertNull(d); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getDate(int, java.util.Calendar)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Not fully supported", |
| method = "getDate", |
| args = {int.class, java.util.Calendar.class} |
| ) |
| public void testGetDateIntCalendar() { |
| GregorianCalendar testCal = new GregorianCalendar(1799, Calendar.MAY, 26, 0, 0); |
| try { |
| |
| Date input = new Date(testCal.getTimeInMillis()); |
| Date d = res.getDate(15, testCal); |
| |
| assertEquals(input.toString(),"1799-05-26"); |
| assertEquals(input,d); |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| try { |
| Date d = res.getDate(500, testCal); |
| fail("Should get exception"); |
| } catch (SQLException e) { |
| //ok |
| } catch (Exception e) { |
| fail("Got unspecified Exception "+ e.getMessage()); |
| } |
| |
| |
| // null value |
| try { |
| assertTrue(res.next()); |
| Date d = res.getDate(15,testCal); |
| assertNull(d); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getDate(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Not fully supported", |
| method = "getDate", |
| args = {java.lang.String.class} |
| ) |
| public void testGetDateString() { |
| try { |
| GregorianCalendar testCal = new GregorianCalendar(1799, Calendar.MAY, 26, 0, 0); |
| Date input = new Date(testCal.getTimeInMillis()); |
| Date d = res.getDate("dateVal"); |
| assertEquals(input.toString(),"1799-05-26"); |
| assertEquals(input,d); |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| try { |
| Date d = res.getDate("bla"); |
| fail("Should get exception"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| // null value |
| try { |
| assertTrue(res.next()); |
| Date d = res.getDate("dateVal"); |
| assertNull(d); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getDate(java.lang.String, java.util.Calendar)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getDate", |
| args = {java.lang.String.class, java.util.Calendar.class} |
| ) |
| public void testGetDateStringCalendar() { |
| GregorianCalendar testCal = new GregorianCalendar(1799, Calendar.MAY, 26, 0, 0); |
| try { |
| Date input = new Date(testCal.getTimeInMillis()); |
| Date d = res.getDate("dateVal", testCal); |
| |
| assertEquals(input.toString(),"1799-05-26"); |
| assertEquals(input,d); |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| try { |
| Date d = res.getDate("bla", testCal); |
| fail("Should get exception"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| // null value |
| try { |
| assertTrue(res.next()); |
| Date d = res.getDate("dateVal",testCal); |
| assertNull(d); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getDouble(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getDouble", |
| args = {int.class} |
| ) |
| public void testGetDoubleInt() { |
| |
| double output = 0.0; |
| try { |
| double[] input = {2.0, 3.9 , 23.2}; |
| |
| output = res.getDouble(8); |
| assertEquals(input[0],output); |
| |
| output = res.getDouble(9); |
| assertEquals(input[1],output); |
| |
| output = res.getDouble(10); |
| assertEquals(input[2],output); |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getDouble(500); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| // null value |
| try { |
| res.next(); |
| output = res.getDouble(8); |
| assertEquals(0.0,output); |
| |
| output = res.getDouble(9); |
| assertEquals(0.0,output); |
| |
| output = res.getDouble(10); |
| assertEquals(0.0,output); |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getDouble(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Not fully supported: eg. getDouble from TinyInt ", |
| method = "getDouble", |
| args = {java.lang.String.class} |
| ) |
| public void testGetDoubleString() { |
| double input = 23.2; |
| double output = 0.0; |
| |
| try{ |
| output = res.getDouble("DoubleVal"); |
| assertEquals (input,output); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try{ |
| output = res.getDouble("bla"); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| |
| // null value |
| try{ |
| assertTrue(res.next()); |
| output = res.getDouble("DoubleVal"); |
| assertEquals (0.0 , output); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getFloat(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Not fully supported: eg.: getFloat from TinyInt according to JDBC 1.0 spec", |
| method = "getFloat", |
| args = {int.class} |
| ) |
| public void testGetFloatInt() { |
| float defaultF = 0.0f; |
| try { |
| float[] input = {3.9f, 23.2f, 33.3f}; |
| |
| |
| float output = res.getFloat(9); |
| assertEquals(input[0], output); |
| |
| output = res.getFloat(10); |
| assertEquals(input[1], output); |
| |
| output = res.getFloat(11); |
| assertEquals(input[2], output); |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getFloat(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| try { |
| res.next(); |
| float output = res.getFloat(8); |
| assertEquals(defaultF, output); |
| |
| output = res.getFloat(9); |
| assertEquals(defaultF, output); |
| |
| output = res.getFloat(10); |
| assertEquals(defaultF, output); |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getFloat(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Not fully supported", |
| method = "getFloat", |
| args = {java.lang.String.class} |
| ) |
| public void testGetFloatString() { |
| float defaultF = 0.0f; |
| try { |
| String[] input = {"RealVal", "DoubleVal", "FloatVal"}; |
| float[] inputF = {3.9f, 23.2f, 33.3f}; |
| |
| |
| float output = res.getFloat(input[0]); |
| assertEquals(inputF[0], output); |
| |
| output = res.getFloat(input[1]); |
| assertEquals(inputF[1], output); |
| |
| output = res.getFloat(input[2]); |
| assertEquals(inputF[2], output); |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getFloat(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| try { |
| res.next(); |
| float output = res.getFloat(8); |
| assertEquals(defaultF, output); |
| |
| output = res.getFloat(9); |
| assertEquals(defaultF, output); |
| |
| output = res.getFloat(10); |
| assertEquals(defaultF, output); |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getInt(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getInt", |
| args = {int.class} |
| ) |
| public void testGetIntInt() { |
| |
| // real input val -1, 22, 2, 33,3, 1, 2 |
| List<Integer> input = Arrays.asList(1, -1, 22, 2, 33,3, 1, 2); |
| ListIterator<Integer> it = input.listIterator(); |
| Double test2 = new Double(23.2); |
| try { |
| for (int i = 1;i<9;i++ ) { |
| assertEquals(it.next().intValue(),res.getInt(i)); |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getInt(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| try { |
| res.next(); |
| for (int i = 2;i<11;i++ ) { |
| assertEquals(0,res.getInt(i)); |
| } |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getInt(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getInt", |
| args = {java.lang.String.class} |
| ) |
| public void testGetIntString() { |
| List<String> inputS = Arrays.asList("BoolVal", "IntVal", "LongVal", |
| "Bint", "Tint", "Sint", "Mint", "IntegerVal"); |
| ListIterator<String> itS = inputS.listIterator(); |
| List<Integer> input = Arrays.asList(1, -1, 22, 2, 33, 3, 1, 2); |
| ListIterator<Integer> it = input.listIterator(); |
| try { |
| while (it.hasNext()) { |
| assertEquals(it.next().intValue(), res.getInt(itS.next())); |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getInt("bla"); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| try { |
| res.next(); |
| for (String s : inputS) { |
| assertEquals(0, res.getInt(s)); |
| } |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getLong(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getLong", |
| args = {int.class} |
| ) |
| public void testGetLongInt() { |
| long maxVal = Long.MAX_VALUE; |
| long minVal = Long.MIN_VALUE; |
| |
| try { |
| assertEquals(maxVal, res.getLong(27)); |
| assertEquals(minVal, res.getLong(28)); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getInt(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| try { |
| res.next(); |
| |
| assertEquals(0,res.getLong(27)); |
| assertEquals(0,res.getLong(28)); |
| |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getLong(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getLong", |
| args = {java.lang.String.class} |
| ) |
| public void testGetLongString() { |
| long maxVal = Long.MAX_VALUE; |
| long minVal = Long.MIN_VALUE; |
| |
| try { |
| assertEquals(maxVal, res.getLong("MaxLongVal")); |
| assertEquals(minVal, res.getLong("MinLongVal")); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getInt("bla"); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| try { |
| res.next(); |
| |
| assertEquals(0,res.getLong("MaxLongVal")); |
| assertEquals(0,res.getLong("MinLongVal")); |
| |
| |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getMetaData()}. |
| * type mappings according to |
| * http://java.sun.com/j2se/1.3/docs/guide/jdbc/spec/jdbc-spec.frame8.html |
| * Not supported datatypes are not checked. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "checks supported data types ,not supported types are not checked.", |
| method = "getMetaData", |
| args = {} |
| ) |
| }) |
| @KnownFailure("Wrong value returned for Long: java.lang.String (VARCHAR)") |
| public void testGetMetaData() { |
| /* |
| * List<String> types = Arrays.asList("BOOLEAN", "INT", "LONG", |
| * "BIGINT", "TINYINT", "SMALLINT", "MEDIUMINT", "INTEGER", "REAL", |
| * "DOUBLE", "FLOAT", "DECIMAL", "NUMERIC", "CHAR(20)", "DATE", "TIME", |
| * "TIMESTAMP", "DATETIME", "TINYBLOB", "BLOB", "MEDIUMBLOB", |
| * "LONGBLOB", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT", "BIGINT", |
| * "BIGINT","URL","URL"); |
| */ |
| List<String> types = Arrays.asList("VARCHAR", "INTEGER", "INTEGER", |
| "BIGINT", "SMALLINT", "SHORT", "INTEGER", "INTEGER", "FLOAT", |
| "DOUBLE", "DOUBLE", "DECIMAL", "NUMERIC", "VARCHAR", "DATE", |
| "TIME", "TIMESTAMP", "DATETIME", "BLOB", "BLOB", "BLOB", |
| "BLOB", "VARCHAR", "VARCHAR", "VARCHAR", "VARCHAR", "BIGINT", |
| "BIGINT", "URL", "URL"); |
| |
| |
| |
| ListIterator<String> it = types.listIterator(); |
| ListIterator<String> colNameIt = colNames.listIterator(); |
| try { |
| ResultSetMetaData meta = res.getMetaData(); |
| assertNotNull(meta); |
| assertEquals("Error in test setup. Columns do not match", types |
| .size(), meta.getColumnCount()); |
| for (int i = 1; i < 31; i++) { |
| String colName = colNameIt.next(); |
| String type = it.next(); |
| if (supported[i - 1]) { |
| assertTrue("Wrong column name at " + i, colName |
| .equalsIgnoreCase(meta.getColumnName(i))); |
| assertTrue("Wrong type at " + i+" required" +type+ " but is "+meta.getColumnTypeName(i), type.equalsIgnoreCase(meta |
| .getColumnTypeName(i))); |
| } |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getObject(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not supported types BIT,VARBINARY, LONGVARBINARY, BINARY, VARCHAR, LONGVARCHAR", |
| method = "getObject", |
| args = {int.class} |
| ) |
| @KnownFailure("Wrong value returned for Long: java.lang.String") |
| public void testGetObjectInt() { |
| |
| try { |
| for (int i = 1; i <= typeMap.length; i++) { |
| if (supported[i-1]) { |
| Object value = res.getObject(i); |
| assertTrue("value " + value.getClass().getName() |
| + " does not correspond " + typeMap[i-1] + "at "+i, value |
| .getClass().equals(typeMap[i-1])); |
| } |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getObject(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| try { |
| res.next(); |
| for (int i = 1; i <= typeMap.length; i++) { |
| Object value = res.getObject(i); |
| assertNull(value); |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| |
| } |
| |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getObject(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not fully supported", |
| method = "getObject", |
| args = {java.lang.String.class} |
| ) |
| @KnownFailure("Wrong value returned for Long: java.lang.String") |
| public void testGetObjectString() { |
| ListIterator<String> colNameIt = colNames.listIterator(); |
| try { |
| for (int i = 1; i <= typeMap.length; i++) { |
| String name = colNameIt.next(); |
| if (supported[i-1]) { |
| Object value = res.getObject(name); |
| assertTrue("value " + value.getClass().getName() |
| + " for "+name+" does not correspond " + typeMap[i-1] + "at "+i, value |
| .getClass().equals(typeMap[i-1])); |
| } |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getObject("bla"); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| |
| try { |
| colNameIt = colNames.listIterator(); |
| res.next(); |
| for (int i = 1; i <= typeMap.length; i++) { |
| Object value = res.getObject(colNameIt.next()); |
| assertNull(value); |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| } |
| |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getRow()}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Exception testing missed, test fails. According to spec afterlast row is 0 but returns 3", |
| method = "getRow", |
| args = {} |
| ) |
| @KnownFailure("If there is no current row 0 must be returned. res.close() does not wrap up") |
| public void testGetRow() { |
| try { |
| assertEquals(1, res.getRow()); |
| assertTrue(res.isFirst()); |
| res.next(); |
| assertEquals(2, res.getRow()); |
| assertTrue(res.isLast()); |
| res.next(); |
| assertTrue(res.isAfterLast()); |
| assertEquals(0, res.getRow()); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.close(); |
| res.getRow(); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getShort(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getShort", |
| args = {int.class} |
| ) |
| public void testGetShortInt() { |
| try { |
| short shorty = res.getShort(6); |
| assertEquals(3,shorty); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.next(); |
| short shorty = res.getShort(6); |
| assertEquals(0,shorty); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| |
| try { |
| res.getShort(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getShort(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getShort", |
| args = {java.lang.String.class} |
| ) |
| public void testGetShortString() { |
| try { |
| short shorty = res.getShort("Sint"); |
| assertEquals(3,shorty); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.next(); |
| short shorty = res.getShort("Sint"); |
| assertEquals(0,shorty); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| |
| try { |
| res.getShort("bla"); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getStatement()}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "test fails. According to spec info.getStatement should return"+ |
| " null but an exception is thrown: stale result set.", |
| method = "getStatement", |
| args = {} |
| ) |
| @KnownFailure("According to spec info.getStatement should return null"+ |
| " but an exception is thrown: stale result set.") |
| public void testGetStatement() { |
| try { |
| DatabaseMetaData meta = conn.getMetaData(); |
| ResultSet info = meta.getTypeInfo(); |
| Statement statement2 = info.getStatement(); |
| assertNull(statement2); |
| } catch(SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| Statement statement2 = res.getStatement(); |
| assertEquals(st, statement2); |
| } catch(SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| // exception testing |
| try { |
| res.close(); |
| res.getStatement(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getString(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getString", |
| args = {int.class} |
| ) |
| public void testGetStringInt() { |
| List<String> texts = Arrays.asList("Test text message tiny", |
| "Test text", "Test text message medium", |
| "Test text message long"); |
| int i = 23; |
| |
| //text and exception testing |
| try { |
| for (String t : texts) { |
| assertEquals(t, res.getString(i)); |
| i++; |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| // the rest: everything should work with getString |
| |
| texts = Arrays.asList("1", "-1", "22", "2", "33", |
| "3","1","2","3.9","23.2","33.3","44", |
| "5", "test string", "1799-05-26", "12:35:45", "2007-10-09 14:28:02.0", |
| "1221-09-22 10:11:55","1","2","3","4"); |
| i= 1; |
| |
| try { |
| for (String t : texts) { |
| assertEquals(t, res.getString(i)); |
| i++; |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| //null testing |
| |
| try { |
| i = 1; |
| res.next(); |
| for (String t : values) { |
| assertNull(res.getString(i)); |
| i++; |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| // exception testing |
| try { |
| res.getString(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getString(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "exception test missed", |
| method = "getString", |
| args = {java.lang.String.class} |
| ) |
| public void testGetStringString() { |
| |
| ListIterator<String> colNameIt = colNames.listIterator(); |
| try { |
| for (String t : values) { |
| assertEquals(t, res.getString(colNameIt.next())); |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.next(); |
| |
| for (String name: colNames) { |
| assertNull(res.getString(name)); |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getString("bla"); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getTime(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getTime", |
| args = {int.class} |
| ) |
| @KnownFailure("getTime should return Time value for a TIMESTAMP type but returns null") |
| public void testGetTimeInt() { |
| // values "12:35:45", "2007-10-09 14:28:02.0", "1221-09-22 10:11:55" |
| |
| Calendar cal = new GregorianCalendar(); |
| cal.clear(); |
| cal.set(Calendar.HOUR_OF_DAY, 12); |
| cal.set(Calendar.MINUTE, 35); |
| cal.set(Calendar.SECOND, 45); |
| cal.set(Calendar.MILLISECOND, 0); |
| // set with calendar value (correct init time: since epoch) |
| long millis = cal.getTime().getTime(); |
| Time t1 = new java.sql.Time(millis); |
| assertNotNull("t1", t1); |
| |
| |
| Calendar cal2 = new GregorianCalendar(); |
| cal2.set(Calendar.YEAR, 2007); |
| cal2.set(Calendar.MONTH, Calendar.OCTOBER); |
| cal2.set(Calendar.DATE, 9); |
| cal2.set(Calendar.HOUR_OF_DAY, 14); |
| cal2.set(Calendar.MINUTE, 28); |
| cal2.set(Calendar.SECOND, 02); |
| cal2.set(Calendar.MILLISECOND, 0); |
| |
| long millis2 = cal2.getTime().getTime(); |
| Time t2 = new java.sql.Time(millis2); |
| |
| int i = 16; |
| |
| try { |
| Time resTime = res.getTime(i); |
| assertNotNull("Pos " + i + " null", resTime); |
| assertEquals(t1.toString(), resTime.toString()); |
| assertEquals(t1.getTime(), resTime.getTime()); |
| assertEquals(t1, resTime); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| // Compatibility Test: TIMESTAMP value |
| i = 17; |
| |
| try { |
| Time resTime = res.getTime(i); |
| assertNotNull("Pos " + i + " null", resTime); |
| assertEquals(t2.toString(), resTime.toString()); |
| assertEquals(t2.getTime(), resTime.getTime()); |
| assertEquals(t2, resTime); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| i = 16; |
| res.next(); |
| assertNull(res.getTime(i)); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getTime(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getTime(int, java.util.Calendar)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getTime", |
| args = {int.class, java.util.Calendar.class} |
| ) |
| @KnownFailure("getTime on TIMESTAMP value fails: returns null") |
| public void testGetTimeIntCalendar() { |
| List<Time> times = new LinkedList<Time>(); |
| List<Calendar> cals = new LinkedList<Calendar>(); |
| // Arrays.asList("12:35:45", "2007-10-09 14:28:02.0", |
| // "1221-09-22 10:11:55"); |
| |
| Calendar cal1 = new GregorianCalendar(); |
| cal1.clear(); |
| cal1.set(Calendar.HOUR_OF_DAY, 12); |
| cal1.set(Calendar.MINUTE, 35); |
| cal1.set(Calendar.SECOND, 45); |
| cal1.set(Calendar.MILLISECOND, 0); |
| |
| long millis = cal1.getTime().getTime(); |
| Time t1 = new java.sql.Time(millis); |
| |
| Calendar cal2 = new GregorianCalendar(); |
| cal2.set(Calendar.YEAR, 2007); |
| cal2.set(Calendar.MONTH, Calendar.OCTOBER); |
| cal2.set(Calendar.DATE, 9); |
| cal2.set(Calendar.HOUR_OF_DAY, 14); |
| cal2.set(Calendar.MINUTE, 28); |
| cal2.set(Calendar.SECOND, 02); |
| cal2.set(Calendar.MILLISECOND, 0); |
| |
| long millis2 = cal2.getTime().getTime(); |
| Time t2 = new java.sql.Time(millis2); |
| |
| // TIME value |
| |
| int i = 16; |
| |
| try { |
| Time timeRes = res.getTime(i,new GregorianCalendar()); |
| assertNotNull(timeRes); |
| assertEquals(t1.toString(), timeRes.toString()); |
| assertEquals(t1.getTime(), timeRes.getTime()); |
| assertEquals(t1, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| // TIMESTAMP value |
| i = 17; |
| |
| try { |
| Time timeRes = res.getTime(i,new GregorianCalendar()); |
| assertNotNull(timeRes); |
| assertEquals(t2.toString(), timeRes.toString()); |
| assertEquals(t2.getTime(), timeRes.getTime()); |
| assertEquals(t2, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.next(); |
| |
| for (Calendar c : cals) { |
| assertNull(res.getTime(16,c)); |
| i++; |
| } |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getTime(500,Calendar.getInstance()); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getTime(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "", |
| method = "getTime", |
| args = {java.lang.String.class} |
| ) |
| @KnownFailure("getTime should return a Time value for a TIMESTAMP type but returns null") |
| public void testGetTimeString() { |
| List<Time> times = new LinkedList<Time>(); |
| |
| List<String> stringTimes = Arrays.asList("timeVal", "TS", "DT"); |
| Iterator<String> it = stringTimes.iterator(); |
| |
| // Arrays.asList("12:35:45", "2007-10-09 14:28:02.0", |
| // "1221-09-22 10:11:55"); |
| |
| Calendar cal = new GregorianCalendar(); |
| cal.clear(); |
| cal.set(Calendar.HOUR_OF_DAY, 12); |
| cal.set(Calendar.MINUTE, 35); |
| cal.set(Calendar.SECOND, 45); |
| cal.set(Calendar.MILLISECOND, 0); |
| |
| long millis = cal.getTime().getTime(); |
| Time t1 = new java.sql.Time(millis); |
| |
| String col = it.next(); |
| |
| try { |
| Time timeRes = res.getTime(col); |
| assertNotNull(timeRes); |
| assertEquals(t1.toString(), timeRes.toString()); |
| assertEquals(t1.getTime(), timeRes.getTime()); |
| assertEquals(t1, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| Calendar cal2 = new GregorianCalendar(); |
| cal2.set(Calendar.YEAR, 2007); |
| cal2.set(Calendar.MONTH, Calendar.OCTOBER); |
| cal2.set(Calendar.DATE, 9); |
| cal2.set(Calendar.HOUR_OF_DAY, 14); |
| cal2.set(Calendar.MINUTE, 28); |
| cal2.set(Calendar.SECOND, 02); |
| cal2.set(Calendar.MILLISECOND, 0); |
| |
| long millis2 = cal.getTime().getTime(); |
| Time t2 = new java.sql.Time(millis2); |
| |
| col = it.next(); |
| |
| try { |
| Time timeRes = res.getTime(col); |
| assertNotNull(timeRes); |
| assertEquals(t2.toString(), timeRes.toString()); |
| assertEquals(t2.getTime(), timeRes.getTime()); |
| assertEquals(t2, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| |
| try { |
| res.next(); |
| |
| assertNull(res.getTime(col)); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getTime("bla"); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getTime(java.lang.String, java.util.Calendar)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Testing getTime with TIME, TIMESTAMP value", |
| method = "getTime", |
| args = {java.lang.String.class, java.util.Calendar.class} |
| ) |
| @KnownFailure("getTime on TIMESTAMP value fails: returns null") |
| public void testGetTimeStringCalendar() { |
| List<Time> times = new LinkedList<Time>(); |
| |
| List<String> stringTimes = Arrays.asList("timeVal", "TS", "DT"); |
| Iterator<String> it = stringTimes.iterator(); |
| List<Calendar> cals = new LinkedList<Calendar>(); |
| |
| // Arrays.asList("12:35:45", "2007-10-09 14:28:02.0", |
| // "1221-09-22 10:11:55"); |
| |
| Calendar cal1 = new GregorianCalendar(); |
| cal1.clear(); |
| cal1.set(Calendar.HOUR_OF_DAY, 12); |
| cal1.set(Calendar.MINUTE, 35); |
| cal1.set(Calendar.SECOND, 45); |
| cal1.set(Calendar.MILLISECOND, 0); |
| |
| long millis = cal1.getTime().getTime(); |
| Time t1 = new java.sql.Time(millis); |
| |
| Calendar cal2 = new GregorianCalendar(); |
| cal2.set(Calendar.YEAR, 2007); |
| cal2.set(Calendar.MONTH, Calendar.OCTOBER); |
| cal2.set(Calendar.DATE, 9); |
| cal2.set(Calendar.HOUR_OF_DAY, 14); |
| cal2.set(Calendar.MINUTE, 28); |
| cal2.set(Calendar.SECOND, 02); |
| cal2.set(Calendar.MILLISECOND, 0); |
| |
| long millis2 = cal2.getTime().getTime(); |
| Time t2 = new java.sql.Time(millis2); |
| |
| // TIME value |
| String col = it.next(); |
| |
| try { |
| Time timeRes = res.getTime(col, new GregorianCalendar()); |
| assertNotNull(timeRes); |
| assertEquals(t1.toString(), timeRes.toString()); |
| assertEquals(t1.getTime(), timeRes.getTime()); |
| assertEquals(t1, res.getTime(col)); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| //TIMESTAMP value |
| col = it.next(); |
| |
| try { |
| Time timeRes = res.getTime(col, new GregorianCalendar()); |
| assertNotNull(timeRes); |
| assertEquals(t2.toString(), timeRes.toString()); |
| assertEquals(t2.getTime(), timeRes.getTime()); |
| assertEquals(t2, res.getTime(col)); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| |
| |
| try { |
| res.next(); |
| assertNull(res.getTime(stringTimes.get(0), new GregorianCalendar())); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getTime("bla"); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getTimestamp(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getTimestamp", |
| args = {int.class} |
| ) |
| public void testGetTimestampInt() { |
| List<Timestamp> times = new LinkedList<Timestamp>(); |
| |
| List<String> stringTimes = Arrays.asList("timeVal", "TS", "DT"); |
| Iterator<String> it = stringTimes.iterator(); |
| List<Calendar> cals = new LinkedList<Calendar>(); |
| |
| Calendar cal2 = new GregorianCalendar(); |
| cal2.set(Calendar.YEAR, 2007); |
| cal2.set(Calendar.MONTH, Calendar.OCTOBER); |
| cal2.set(Calendar.DATE, 9); |
| cal2.set(Calendar.HOUR_OF_DAY, 14); |
| cal2.set(Calendar.MINUTE, 28); |
| cal2.set(Calendar.SECOND, 02); |
| cal2.set(Calendar.MILLISECOND, 0); |
| |
| long millis = cal2.getTime().getTime(); |
| Timestamp t2 = new Timestamp(millis); |
| times.add(t2); |
| |
| Calendar cal3 = new GregorianCalendar(); |
| cal3.set(Calendar.YEAR, 1221); |
| cal3.set(Calendar.MONTH, Calendar.SEPTEMBER); |
| cal3.set(Calendar.DATE, 22); |
| cal3.set(Calendar.HOUR_OF_DAY, 10); |
| cal3.set(Calendar.MINUTE, 11); |
| cal3.set(Calendar.SECOND, 55); |
| cal3.set(Calendar.MILLISECOND, 0); |
| |
| millis = cal3.getTime().getTime(); |
| Timestamp t3 = new Timestamp(millis); |
| times.add(t3); |
| // TIMESTAMP value |
| int i = 17; |
| |
| try { |
| Timestamp timeRes = res.getTimestamp(i); |
| assertEquals(t2.toString(), timeRes.toString()); |
| assertEquals(t2.getTime(), timeRes.getTime()); |
| assertEquals(t2, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| // DATE value |
| i = 18; |
| try { |
| Timestamp timeRes = res.getTimestamp(i); |
| assertEquals(t3.toString(), timeRes.toString()); |
| assertEquals(t3.getTime(), timeRes.getTime()); |
| assertEquals(t3, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.next(); |
| assertNull(res.getTime(i)); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getTime(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getTimestamp(int, java.util.Calendar)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getTimestamp", |
| args = {int.class, java.util.Calendar.class} |
| ) |
| public void testGetTimestampIntCalendar() { |
| List<Timestamp> times = new LinkedList<Timestamp>(); |
| |
| List<String> stringTimes = Arrays.asList("timeVal", "TS", "DT"); |
| Iterator<String> it = stringTimes.iterator(); |
| // List<Calendar> cals = new LinkedList<Calendar>(); |
| |
| Calendar cal2 = new GregorianCalendar(); |
| cal2.set(Calendar.YEAR, 2007); |
| cal2.set(Calendar.MONTH, Calendar.OCTOBER); |
| cal2.set(Calendar.DATE, 9); |
| cal2.set(Calendar.HOUR_OF_DAY, 14); |
| cal2.set(Calendar.MINUTE, 28); |
| cal2.set(Calendar.SECOND, 02); |
| cal2.set(Calendar.MILLISECOND, 0); |
| |
| long millis = cal2.getTime().getTime(); |
| Timestamp t2 = new Timestamp(millis); |
| times.add(t2); |
| // |
| Calendar cal3 = new GregorianCalendar(); |
| cal3.set(Calendar.YEAR, 1221); |
| cal3.set(Calendar.MONTH, Calendar.SEPTEMBER); |
| cal3.set(Calendar.DATE, 22); |
| cal3.set(Calendar.HOUR_OF_DAY, 10); |
| cal3.set(Calendar.MINUTE, 11); |
| cal3.set(Calendar.SECOND, 55); |
| cal3.set(Calendar.MILLISECOND, 0); |
| |
| millis = cal3.getTime().getTime(); |
| Timestamp t3 = new Timestamp(millis); |
| times.add(t3); |
| |
| // cals.add(cal1); |
| // cals.add(cal2); |
| // cals.add(cal3); |
| // |
| // ListIterator<Calendar> calIt = cals.listIterator(); |
| |
| int i = 17; |
| |
| try { |
| Timestamp timeRes = res.getTimestamp(i,new GregorianCalendar()); |
| assertEquals(t2.toString(), timeRes.toString()); |
| assertEquals(t2, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| i = 18; |
| |
| try { |
| Timestamp timeRes = res.getTimestamp(i,new GregorianCalendar()); |
| assertEquals(t3.toString(), timeRes.toString()); |
| assertEquals(t3, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.next(); |
| assertNull(res.getTime(17,cal2)); |
| assertNull(res.getTime(18,cal3)); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getTime(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getTimestamp(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getTimestamp", |
| args = {java.lang.String.class} |
| ) |
| public void testGetTimestampString() { |
| List<Timestamp> times = new LinkedList<Timestamp>(); |
| |
| List<String> stringTimes = Arrays.asList( "TS", "DT"); |
| Iterator<String> it = stringTimes.iterator(); |
| // List<Calendar> cals = new LinkedList<Calendar>(); |
| |
| Calendar cal2 = new GregorianCalendar(); |
| cal2.set(Calendar.YEAR, 2007); |
| cal2.set(Calendar.MONTH, Calendar.OCTOBER); |
| cal2.set(Calendar.DATE, 9); |
| cal2.set(Calendar.HOUR_OF_DAY, 14); |
| cal2.set(Calendar.MINUTE, 28); |
| cal2.set(Calendar.SECOND, 02); |
| cal2.set(Calendar.MILLISECOND, 0); |
| |
| long millis = cal2.getTime().getTime(); |
| Timestamp t2 = new Timestamp(millis); |
| times.add(t2); |
| // |
| Calendar cal3 = new GregorianCalendar(); |
| cal3.set(Calendar.YEAR, 1221); |
| cal3.set(Calendar.MONTH, Calendar.SEPTEMBER); |
| cal3.set(Calendar.DATE, 22); |
| cal3.set(Calendar.HOUR_OF_DAY, 10); |
| cal3.set(Calendar.MINUTE, 11); |
| cal3.set(Calendar.SECOND, 55); |
| cal3.set(Calendar.MILLISECOND, 0); |
| |
| millis = cal3.getTime().getTime(); |
| Timestamp t3 = new Timestamp(millis); |
| times.add(t3); |
| |
| String col = it.next(); |
| |
| try { |
| Timestamp timeRes = res.getTimestamp(col); |
| assertEquals(t2.toString(), timeRes.toString()); |
| assertEquals(t2.toString(), timeRes.toString()); |
| assertEquals(t2.getTime(), timeRes.getTime()); |
| assertEquals(t2, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| // DATE value |
| col = it.next(); |
| |
| try { |
| Timestamp timeRes = res.getTimestamp(col); |
| assertEquals(t3.toString(), timeRes.toString()); |
| assertEquals(t3.toString(), timeRes.toString()); |
| assertEquals(t3.getTime(), timeRes.getTime()); |
| assertEquals(t3, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.next(); |
| assertNull(res.getTime(stringTimes.get(0))); |
| assertNull(res.getTime(stringTimes.get(1))); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getTime(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getTimestamp(java.lang.String, java.util.Calendar)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getTimestamp", |
| args = {java.lang.String.class, java.util.Calendar.class} |
| ) |
| public void testGetTimestampStringCalendar() { |
| List<Timestamp> times = new LinkedList<Timestamp>(); |
| |
| List<String> stringTimes = Arrays.asList( "TS", "DT"); |
| Iterator<String> it = stringTimes.iterator(); |
| |
| Calendar cal2 = new GregorianCalendar(); |
| cal2.set(Calendar.YEAR, 2007); |
| cal2.set(Calendar.MONTH, Calendar.OCTOBER); |
| cal2.set(Calendar.DATE, 9); |
| cal2.set(Calendar.HOUR_OF_DAY, 14); |
| cal2.set(Calendar.MINUTE, 28); |
| cal2.set(Calendar.SECOND, 02); |
| cal2.set(Calendar.MILLISECOND, 0); |
| |
| long millis = cal2.getTime().getTime(); |
| Timestamp t2 = new Timestamp(millis); |
| times.add(t2); |
| // |
| Calendar cal3 = new GregorianCalendar(); |
| cal3.set(Calendar.YEAR, 1221); |
| cal3.set(Calendar.MONTH, Calendar.SEPTEMBER); |
| cal3.set(Calendar.DATE, 22); |
| cal3.set(Calendar.HOUR_OF_DAY, 10); |
| cal3.set(Calendar.MINUTE, 11); |
| cal3.set(Calendar.SECOND, 55); |
| cal3.set(Calendar.MILLISECOND, 0); |
| |
| millis = cal3.getTime().getTime(); |
| Timestamp t3 = new Timestamp(millis); |
| times.add(t3); |
| |
| try { |
| Timestamp timeRes = res.getTimestamp(stringTimes.get(0),cal2); |
| assertEquals(t2.toString(), timeRes.toString()); |
| assertEquals(t2.getTime(), timeRes.getTime()); |
| assertEquals(t2, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| // DATE value |
| try { |
| Timestamp timeRes = res.getTimestamp(stringTimes.get(1),cal3); |
| assertEquals(t3.toString(), timeRes.toString()); |
| assertEquals(t3.getTime(), timeRes.getTime()); |
| assertEquals(t3, timeRes); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| // calIt = cals.listIterator(); |
| |
| try { |
| res.next(); |
| assertNull(res.getTime(stringTimes.get(0),cal2)); |
| assertNull(res.getTime(stringTimes.get(1),cal3)); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| try { |
| res.getTime(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getType()}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "SQLException checking missed. Only one ResultSet type supported: default values, Test fails.Not fully supported. Always returns ResultSet.TYPE_SCROLL_INSENSITIVE. Wrong default value.", |
| method = "getType", |
| args = {} |
| ) |
| @KnownFailure("res.close() does not wrap up") |
| public void testGetType() { |
| try { |
| assertEquals(ResultSet.TYPE_FORWARD_ONLY, res.getType()); |
| } catch (SQLException e) { |
| fail("Unexpected exception " + e.getMessage()); |
| } |
| |
| try { |
| st.close(); |
| res.getType(); |
| fail("Exception not thrown."); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| } |
| |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getURL(int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not fully supported type", |
| method = "getURL", |
| args = {int.class} |
| ) |
| public void testGetURLInt() { |
| try { |
| URL input = new URL("http://www.android.com"); |
| URL validURL = res.getURL(29); |
| assertEquals(input, validURL); |
| } catch (SQLException e) { |
| fail("Unexpected exception " + e.getMessage()); |
| } catch (MalformedURLException e) { |
| fail("Unexpected exception " + e.getMessage()); |
| } |
| |
| try { |
| URL invalidURL = res.getURL(30); |
| assertNull(invalidURL); |
| } catch (SQLException e) { |
| // ok |
| } |
| |
| try { |
| res.next(); |
| assertNull(res.getURL(29)); |
| assertNull(res.getURL(30)); |
| } catch (SQLException e) { |
| fail("Unexpected exception " + e.getMessage()); |
| } |
| |
| try { |
| res.getURL(500); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#getURL(java.lang.String)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not fully supported type", |
| method = "getURL", |
| args = {java.lang.String.class} |
| ) |
| public void testGetURLString() { |
| try { |
| URL input = new URL("http://www.android.com"); |
| URL validURL = res.getURL("validURL"); |
| assertEquals(input, validURL); |
| } catch (SQLException e) { |
| fail("Unexpected exception " + e.getMessage()); |
| } catch (MalformedURLException e) { |
| fail("Unexpected exception " + e.getMessage()); |
| } |
| |
| try { |
| URL invalidURL = res.getURL("invalidURL"); |
| assertNull(invalidURL); |
| } catch (SQLException e) { |
| // ok |
| } |
| |
| try { |
| res.next(); |
| assertNull(res.getURL("validURL")); |
| assertNull(res.getURL("invalidURL")); |
| } catch (SQLException e) { |
| fail("Unexpected exception " + e.getMessage()); |
| } |
| |
| try { |
| res.getURL("bla"); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| } |
