| /* |
| * 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.sql.BatchUpdateException; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.SQLWarning; |
| import java.sql.Statement; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.Vector; |
| import java.util.logging.Logger; |
| |
| @TestTargetClass(Statement.class) |
| public class StatementTest extends SQLTest { |
| |
| /** |
| * @test java.sql.Statement#addBatch(String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "addBatch", |
| args = {java.lang.String.class} |
| ) |
| public void testAddBatch() throws SQLException { |
| |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.addBatch("INSERT INTO zoo VALUES (3,'Tuzik','dog')"); |
| st.addBatch("INSERT INTO zoo VALUES (4,'Mashka','cat')"); |
| |
| int[] updateCounts = st.executeBatch(); |
| assertEquals(2, updateCounts.length); |
| assertEquals(1, updateCounts[0]); |
| assertEquals(1, updateCounts[1]); |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown"); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(); |
| st.addBatch(""); |
| st.executeBatch(); |
| fail("SQLException is not thrown"); |
| } catch (SQLException e) { |
| // expected |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(); |
| st.addBatch(null); |
| st.executeBatch(); |
| } catch (SQLException e) { |
| // expected |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#clearWarnings() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "clearWarnings", |
| args = {} |
| ) |
| public void testClearWarnings() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.execute("select animals from zoo"); |
| } catch (SQLException e) { |
| // expected |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| try { |
| st = conn.createStatement(); |
| st.clearWarnings(); |
| SQLWarning w = st.getWarnings(); |
| assertNull(w); |
| } catch (Exception e) { |
| fail("Unexpected Exception: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#getWarnings() |
| * |
| * TODO getWarnings is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported. always returns null. ", |
| method = "getWarnings", |
| args = {} |
| ) |
| public void testGetWarnings() { |
| |
| Statement st = null; |
| int errorCode1 = -1; |
| int errorCode2 = -1; |
| |
| try { |
| st = conn.createStatement(); |
| st.execute("select animals from zoooo"); |
| fail("SQLException was not thrown"); |
| } catch (SQLException e) { |
| // expected |
| errorCode1 = e.getErrorCode(); |
| } |
| |
| try { |
| SQLWarning wrs = st.getWarnings(); |
| assertNull(wrs); |
| } catch (Exception e) { |
| fail("Change test implementation: get warnings is supported now"); |
| } |
| /* |
| Statement st = null; |
| int errorCode1 = -1; |
| int errorCode2 = -1; |
| |
| try { |
| st = conn.createStatement(); |
| st.execute("select animals from zoooo"); |
| } catch (SQLException e) { |
| // expected |
| errorCode1 = e.getErrorCode(); |
| } |
| try { |
| SQLWarning wrs = st.getWarnings(); |
| assertNull(wrs); |
| } catch (Exception e) { |
| fail("Unexpected Exception: " + e.getMessage()); |
| } |
| try { |
| st.execute("select horse from zoooooo"); |
| } catch (SQLException e) { |
| // expected |
| errorCode2 = e.getErrorCode(); |
| } |
| |
| try { |
| SQLWarning wrs = st.getWarnings(); |
| assertEquals(errorCode1, wrs.getErrorCode()); |
| assertNotNull(wrs.getNextWarning()); |
| assertEquals(errorCode2, wrs.getErrorCode()); |
| } catch (Exception e) { |
| fail("Unexpected Exception: " + e.getMessage()); |
| } |
| |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| */ |
| |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#clearBatch()} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "clearBatch", |
| args = {} |
| ) |
| public void testClearBatch() throws SQLException { |
| |
| Statement st = null; |
| |
| try { |
| st = conn.createStatement(); |
| st.addBatch("INSERT INTO zoo VALUES (3,'Tuzik','dog'); "); |
| st.addBatch("INSERT INTO zoo VALUES (4,'Mashka','cat')"); |
| |
| st.clearBatch(); |
| |
| int[] updateCounts = st.executeBatch(); |
| |
| for (int i = 0; i < updateCounts.length; i++) { |
| assertEquals(0, updateCounts[i]); |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown"); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(); |
| st.addBatch(""); |
| st.executeBatch(); |
| fail("SQLException is not thrown"); |
| } catch (SQLException e) { |
| // expected |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(); |
| st.addBatch(null); |
| st.executeBatch(); |
| } catch (SQLException e) { |
| // expected |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#execute(String sql) |
| * |
| * TODO not pass on SQLite and RI. |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "execute", |
| args = {java.lang.String.class} |
| ) |
| @KnownFailure("Return value wrong for queries below.") |
| public void testExecute() throws SQLException { |
| |
| String[] queries = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "drop table if exists hutch", |
| "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));", |
| "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');", |
| "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');", |
| "select animal_id, address from hutch where animal_id=1;", |
| "create view address as select address from hutch where animal_id=2", |
| "drop view address;", "drop table hutch;" }; |
| boolean[] results = {false, false, false, false, false, true, false, |
| false, false}; |
| |
| for (int i = 0; i < queries.length; i++) { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| boolean res = st.execute(queries[i]); |
| assertEquals("different result for statement no. "+i, results[i], res); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| } |
| |
| String[] inc_queries = { |
| "update zoo_zoo set name='Masha', family='cat' where id=5;", |
| "drop table hutchNO", |
| "insert into hutch (id, animal_id, address) values (1, 2, 10);", |
| "select animal_id, from hutch where animal_id=1;", |
| "drop view address;", "drop table hutch;", "", null }; |
| |
| for (int i = 0; i < inc_queries.length; i++) { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.execute(inc_queries[i]); |
| fail("SQLException is not thrown for query: " + inc_queries[i]); |
| } catch (SQLException e) { |
| // expected |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#execute(String sql, int autoGeneratedKeys) |
| * TODO not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Missing implementation for Statement.RETURN_GENERATED_KEYS: keys not yet supported", |
| method = "execute", |
| args = {java.lang.String.class, int.class} |
| ) |
| public void testExecute_String_int() { |
| String[] queries = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "drop table if exists hutch", |
| "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));", |
| "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');", |
| "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');", |
| "select animal_id, address from hutch where animal_id=1;", |
| "create view address as select address from hutch where animal_id=2", |
| "drop view address;", "drop table hutch;" }; |
| |
| for (int i = 0; i < queries.length; i++) { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.execute(queries[i], Statement.NO_GENERATED_KEYS); |
| |
| ResultSet rs = st.getGeneratedKeys(); |
| assertFalse(rs.next()); |
| |
| } catch (SQLException e) { |
| // ok |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| for (int i = 0; i < queries.length; i++) { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.execute(queries[i], Statement.RETURN_GENERATED_KEYS); |
| fail("Exception expected: Not supported"); |
| /* |
| ResultSet rs = st.getGeneratedKeys(); |
| fail("Revise test implemenation for feature impl. has changed"); |
| assertFalse(rs.next()); |
| */ |
| } catch (SQLException e) { |
| //ok |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#getConnection() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "SQLException test fails", |
| method = "getConnection", |
| args = {} |
| ) |
| @KnownFailure("statment.close() does not wrap up") |
| public void testGetConnection() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| assertSame(conn, st.getConnection()); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st.close(); |
| st.getConnection(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| |
| } |
| |
| /** |
| * @test java.sql.Statement#getFetchDirection() |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "SQLException test fails. Not all Fetch directions supported.", |
| method = "getFetchDirection", |
| args = {} |
| ) |
| @KnownFailure("statment.close() does not wrap up") |
| public void testGetFetchDirection() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| assertEquals(ResultSet.FETCH_UNKNOWN, st.getFetchDirection()); |
| } catch (SQLException e) { |
| fail("SQLException is thrown " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(); |
| st.setFetchDirection(ResultSet.FETCH_FORWARD); |
| assertEquals(ResultSet.FETCH_FORWARD, st.getFetchDirection()); |
| fail("Exception expected: not supported"); |
| } catch (SQLException e) { |
| // ok |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st.getFetchDirection(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#setFetchDirection(int) |
| * TODO not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported. ", |
| method = "setFetchDirection", |
| args = {int.class} |
| ) |
| public void testSetFetchDirection() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.setFetchDirection(ResultSet.FETCH_FORWARD); |
| st.executeQuery("select * from zoo;"); |
| fail("Revise test implemenation for feature impl. has changed"); |
| // assertEquals(ResultSet.FETCH_FORWARD, st.getFetchDirection()); |
| } catch (SQLException e) { |
| // fail("SQLException is thrown: " + e.getMessage()); |
| //ok |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| /* |
| try { |
| st = conn.createStatement(); |
| st.setFetchDirection(-1); |
| fail("SQLException is not thrown"); |
| } catch (SQLException e) { |
| // expected |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(); |
| st.setFetchDirection(100); |
| fail("SQLException is not thrown"); |
| } catch (SQLException e) { |
| // expected |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| */ |
| } |
| |
| /** |
| * @test java.sql.Statement#getFetchSize() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "SQLException test fails", |
| method = "getFetchSize", |
| args = {} |
| ) |
| @KnownFailure("statment.close() does not wrap up") |
| public void testGetFetchSize() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.execute("select * from zoo;"); |
| assertEquals(1, st.getFetchSize()); |
| } catch (SQLException e) { |
| fail("SQLException is thrown"); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st.close(); |
| st.getFetchSize(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#setFetchSize(int)} |
| * TODO not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported.", |
| method = "setFetchSize", |
| args = {int.class} |
| ) |
| public void testSetFetchSize() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| int rows = 100; |
| for (int i = 0; i < rows; i++) { |
| try { |
| st.setFetchSize(i); |
| assertEquals(i, st.getFetchSize()); |
| fail("Revise: test implemenation for feature impl. has changed"); |
| } catch (SQLException sqle) { |
| // fail("SQLException is thrown: " + sqle.toString()); |
| assertEquals("not supported", sqle.getMessage()); |
| } |
| } |
| /* |
| try { |
| st.setFetchSize(-1); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| */ |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown"); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#setMaxFieldSize(int max) |
| * TODO not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "setMaxFieldSize", |
| args = {int.class} |
| ) |
| public void testSetMaxFieldSize() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| for (int i = 0; i < 300; i += 50) { |
| try { |
| st.setMaxFieldSize(i); |
| assertEquals(i, st.getMaxFieldSize()); |
| fail("Revise test implemenation for feature impl. has changed"); |
| } catch (SQLException sqle) { |
| assertEquals("not supported", sqle.getMessage()); |
| // fail("SQLException is thrown: " + sqle.getMessage()); |
| } |
| } |
| /* |
| try { |
| st.setMaxFieldSize(-1); |
| fail("SQLException isn't thrown"); |
| } catch (SQLException sqle) { |
| // expecteds |
| } |
| */ |
| } catch (SQLException e) { |
| fail("Can't create statement, SQLException is thrown: " |
| + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#getMaxFieldSize() |
| * TODO not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "getMaxFieldSize", |
| args = {} |
| ) |
| public void testGetMaxFieldSize() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| for (int i = 200; i < 500; i += 50) { |
| try { |
| st.setMaxFieldSize(i); |
| fail("Revise test implemenation for feature impl. has changed"); |
| } catch (SQLException sqle) { |
| assertEquals("not supported", sqle.getMessage()); |
| // fail("SQLException is thrown: " + sqle.getMessage()); |
| } |
| } |
| } catch (SQLException e) { |
| fail("Can't create statement, SQLException is thrown: " |
| + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#setMaxRows(int max) |
| * TODO not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "setMaxRows", |
| args = {int.class} |
| ) |
| public void testSetMaxRows() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.execute("select * from zoo;"); |
| for (int i = 0; i < 300; i += 50) { |
| try { |
| st.setMaxRows(i); |
| assertEquals(i, st.getMaxRows()); |
| fail("Revise test implemenation for feature impl. has changed"); |
| } catch (SQLException sqle) { |
| assertEquals("not supported", sqle.getMessage()); |
| // fail("SQLException is thrown: " + sqle.getMessage()); |
| } |
| } |
| try { |
| st.setMaxRows(-1); |
| fail("SQLException isn't thrown"); |
| } catch (SQLException sqle) { |
| // expecteds |
| } |
| } catch (SQLException e) { |
| fail("Can't create statement, SQLException is thrown: " |
| + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#getMaxRows() |
| * TODO not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "getMaxRows", |
| args = {} |
| ) |
| public void testGetMaxRows() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| for (int i = 200; i < 500; i += 50) { |
| try { |
| st.setMaxRows(i); |
| assertEquals(i, st.getMaxRows()); |
| fail("Revise test implemenation for feature impl. has changed"); |
| } catch (SQLException sqle) { |
| assertEquals("not supported", sqle.getMessage()); |
| // fail("SQLException is thrown: " + sqle.getMessage()); |
| } |
| } |
| } catch (SQLException e) { |
| fail("Can't create statement, SQLException is thrown: " |
| + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#close() |
| * not passed according to Java Docs: should release all resources |
| * IMMEDIATELY |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "close", |
| args = {} |
| ) |
| @KnownFailure("statment.close() does not wrap up") |
| public void testClose() { |
| Statement st = null; |
| ResultSet res = null; |
| try { |
| String[] queries = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');", |
| "insert into zoo (id, name, family) values (4, 'Slon', 'elephant');", |
| "select * from zoo"}; |
| st = conn.createStatement(); |
| for (int i = 0; i < queries.length; i++) { |
| st.execute(queries[i]); |
| } |
| res = st.getResultSet(); |
| assertNotNull(res); |
| assertTrue(res.next()); |
| st.close(); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| // test release of resources: |
| // this code should throw an exception as the db is not available |
| // anymore in fact every resource which is used afterwards should throw |
| // an SQLException. |
| try { |
| res.next(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| |
| } |
| |
| /** |
| * @test java.sql.Statement#execute(String sql, int[] columnIndexes) |
| * TODO not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "execute", |
| args = {java.lang.String.class, int[].class} |
| ) |
| public void testExecute_String_intArray() { |
| Statement st = null; |
| try { |
| String[] queries = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "insert zoo(id, name, family) values (3, 'Vorobey', 'sparrow');", |
| "insert zoo(id, name, family) values (4, 'Slon', 'elephant');", |
| "select * from zoo" }; |
| Vector<int[]> array = new Vector<int[]>(); |
| array.addElement(null); |
| array.addElement(new int[] { 1, 2, 3 }); |
| array.addElement(new int[] { 1, 2, 10, 100 }); |
| array.addElement(new int[] {}); |
| |
| st = conn.createStatement(); |
| for (int i = 0; i < queries.length; i++) { |
| st.execute(queries[i], (int[]) array.elementAt(i)); |
| fail("SQLException expected: not supported"); |
| } |
| /* |
| fail("Revise test implemenation for feature impl. has changed"); |
| assertNotNull(st.getResultSet()); |
| st.close(); |
| assertNull(st.getResultSet()); |
| */ |
| } catch (SQLException e) { |
| // ok: not supported |
| // fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#execute(String sql, String[] columnNames) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "execute", |
| args = {java.lang.String.class, java.lang.String[].class} |
| ) |
| public void testExecute_String_StringArray() { |
| Statement st = null; |
| try { |
| String[] queries = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "insert zoo(id, name, family) values (3, 'Vorobey', 'sparrow');", |
| "insert zoo(id, name, family) values (4, 'Slon', 'elephant');", |
| "select * from zoo" }; |
| Vector<String[]> array = new Vector<String[]>(); |
| array.addElement(null); |
| array.addElement(new String[] { "", "", "", "", "", "", "", "" }); |
| array.addElement(new String[] { "field 1", "", "field2" }); |
| array.addElement(new String[] { "id", "family", "name" }); |
| |
| st = conn.createStatement(); |
| for (int i = 0; i < queries.length; i++) { |
| st.execute(queries[i], (String[]) array.elementAt(i)); |
| fail("Exception expected: not supported"); |
| } |
| fail("Revise test implemenation for feature impl. has changed"); |
| assertNotNull(st.getResultSet()); |
| st.close(); |
| assertNull(st.getResultSet()); |
| } catch (SQLException e) { |
| // ok: not supported |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#executeBatch() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test fails: dropping table hutch affects at least 2 rows.executeBatch() always returns same result: 1.", |
| method = "executeBatch", |
| args = {} |
| ) |
| @KnownFailure("always returns 1 for no. of updates") |
| public void testExecuteBatch() { |
| |
| String[] queries = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "drop table if exists hutch", |
| "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));", |
| "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');", |
| "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');", |
| "create view address as select address from hutch where animal_id=2", |
| "drop view address;", "drop table hutch;" }; |
| |
| String[] wrongQueries = { |
| "update zoo set name='Masha', family='cat' where;", |
| "drop table if exists hutch;", |
| "create view address as select address from hutch where animal_id=2;", |
| "drop view address;", "drop table hutch;" }; |
| |
| int[] result = { 1, 1, 1, 1, 1, 1, 1, 1 }; |
| Statement st = null; |
| |
| //Exception test |
| try { |
| st = conn.createStatement(); |
| assertEquals(0, st.executeBatch().length); |
| for (int i = 0; i < wrongQueries.length; i++) { |
| st.addBatch(wrongQueries[i]); |
| } |
| st.executeBatch(); |
| fail("BatchupdateException expected"); |
| } catch (BatchUpdateException e) { |
| //ok |
| } catch (SQLException e) { |
| fail("BatchupdateException expected"); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(); |
| assertEquals(0, st.executeBatch().length); |
| for (int i = 0; i < queries.length; i++) { |
| st.addBatch(queries[i]); |
| } |
| int[] resArray = st.executeBatch(); |
| assertTrue(java.util.Arrays.equals(result, resArray)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(); |
| st.addBatch("select * from zoo"); |
| st.executeBatch(); |
| fail("Exception expected"); |
| } catch (BatchUpdateException bue) { |
| // ok select returns a resultSet |
| } catch (SQLException sqle) { |
| fail("Unknown SQLException is thrown: " + sqle.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| //Exception test |
| try { |
| st.close(); |
| st.executeBatch(); |
| fail("SQLException not thrown"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#executeQuery(String sql) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Not according to spec.", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| @KnownFailure("Does throw an exception on non select statment.") |
| public void testExecuteQuery_String() { |
| |
| String[] queries1 = { "select * from zoo", |
| "select name, family from zoo where id = 1" }; |
| |
| String[] queries2 = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "drop table if exists hutch", |
| "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));", |
| "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');", |
| "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');", |
| "create view address as select address from hutch where animal_id=2", |
| "drop view address;", "drop table hutch;", "select from zoo" }; |
| |
| Statement st = null; |
| |
| try { |
| st = conn.createStatement(); |
| for (int i = 0; i < queries1.length; i++) { |
| try { |
| ResultSet rs = st.executeQuery(queries1[i]); |
| assertNotNull(rs); |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown for query: " + queries1[i]); |
| } |
| } |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| // queries which do not produce a ResultSet -> exception testing |
| |
| try { |
| st = conn.createStatement(); |
| for (int i = 0; i < queries2.length; i++) { |
| try { |
| ResultSet rs = st.executeQuery(queries2[i]); |
| assertNotNull(rs); |
| fail("SQLException is not thrown for query: " + queries2[i]); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } |
| } catch (SQLException sqle) { |
| fail("Unknown SQLException is thrown: " + sqle.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| } |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Statement#executeUpdate(String sql) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "impl not according to spec.", |
| method = "executeUpdate", |
| args = {java.lang.String.class} |
| ) |
| @KnownFailure("Spec is not precise enough: should be: number of rows affected."+ |
| " eg. to be consistent for deletes: 'delete from s1;' should be different from "+ |
| "'delete from s1 where c1 = 1;' ") |
| public void testExecuteUpdate_String() throws SQLException { |
| |
| String[] queries1 = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "drop table if exists hutch", |
| "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));", |
| "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');", |
| "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');", |
| "create view address as select address from hutch where animal_id=2;", |
| "drop view address;", "drop table hutch;"}; |
| |
| String queries2 = "select * from zoo;"; |
| |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| for (int i = 0; i < queries1.length; i++) { |
| try { |
| int count = st.executeUpdate(queries1[i]); |
| assertTrue(count > 0); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } |
| } |
| |
| try { |
| assertEquals(0, st.executeUpdate(queries2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| // test return value for specific numbers |
| |
| Statement stat = conn.createStatement(); |
| |
| // there are 0 rows created therefore 0 should be returned. |
| assertEquals(0 ,stat.executeUpdate("create table s1 (c1);")); |
| |
| assertEquals(1, stat.executeUpdate("insert into s1 values (0);")); |
| assertEquals(1, stat.executeUpdate("insert into s1 values (1);")); |
| assertEquals(1, stat.executeUpdate("insert into s1 values (2);")); |
| assertEquals(1,stat.executeUpdate("delete from s1 where c1 = 1;")); |
| assertEquals(2, stat.executeUpdate("update s1 set c1 = 5;")); |
| |
| // analogous to statemente before, delete all should return 2 |
| assertEquals(2,stat.executeUpdate("delete from s1;")); |
| |
| // there are no rows in table: 0 should be returned |
| assertEquals(0, stat.executeUpdate("drop table s1;")); |
| |
| stat.executeUpdate("create table s1 (c1);"); |
| stat.executeUpdate("insert into s1 values (0);"); |
| stat.executeUpdate("insert into s1 values (1);"); |
| stat.executeUpdate("insert into s1 values (2);"); |
| |
| // there are 3 rows in table: 3 should be returned |
| assertEquals(3, stat.executeUpdate("drop table s1;")); |
| |
| stat.close(); |
| } |
| |
| /** |
| * @test java.sql.Statement#executeUpdate(String sql, int[] columnIndexes) |
| * |
| * TODO executeUpdate(String sql, int[] columnIndexes) is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "executeUpdate", |
| args = {java.lang.String.class, int[].class} |
| ) |
| public void testExecuteUpdate_String_intArray() { |
| Statement st = null; |
| try { |
| String[] queries1 = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "drop table if exists hutch", |
| "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));", |
| "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');", |
| "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');", |
| "create view address as select address from hutch where animal_id=2", |
| "drop view address;", "drop table hutch;" }; |
| |
| Vector<int[]> array = new Vector<int[]>(); |
| array.addElement(null); |
| array.addElement(new int[] { 1, 2, 3 }); |
| array.addElement(new int[] { 1, 2, 10, 100 }); |
| array.addElement(new int[] {}); |
| array.addElement(new int[] { 100, 200 }); |
| array.addElement(new int[] { -1, 0 }); |
| array.addElement(new int[] { 0, 0, 0, 1, 2, 3 }); |
| array.addElement(new int[] { -100, -200 }); |
| |
| st = conn.createStatement(); |
| for (int i = 0; i < queries1.length; i++) { |
| st.executeUpdate(queries1[i], (int[]) array.elementAt(i)); |
| fail("Exception expected"); |
| } |
| } catch (SQLException e) { |
| assertEquals("not supported",e.getMessage()); |
| // fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#executeUpdate(String sql, int autoGeneratedKeys) |
| * |
| * TODO executeUpdate(String sql, int autoGeneratedKeys) is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not supported", |
| method = "executeUpdate", |
| args = {java.lang.String.class, int.class} |
| ) |
| public void testExecuteUpdate_String_int() { |
| String[] queries = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "drop table if exists hutch", |
| "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));", |
| "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');", |
| "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');", |
| "select animal_id, address from hutch where animal_id=1;", |
| "create view address as select address from hutch where animal_id=2", |
| "drop view address;", "drop table hutch;" }; |
| |
| Statement st = null; |
| ResultSet rs = null; |
| try { |
| st = conn.createStatement(); |
| st.executeUpdate(queries[1], Statement.NO_GENERATED_KEYS); |
| rs = st.getGeneratedKeys(); |
| assertFalse(rs.next()); |
| fail("Exception expected: not supported"); |
| } catch (SQLException e) { |
| //ok |
| } finally { |
| try { |
| rs.close(); |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(); |
| st.executeUpdate(queries[1], Statement.RETURN_GENERATED_KEYS); |
| rs = st.getGeneratedKeys(); |
| assertTrue(rs.next()); |
| fail("Exception expected: not supported"); |
| } catch (SQLException e) { |
| //ok |
| } finally { |
| try { |
| rs.close(); |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#executeUpdate(String sql, String[] columnNames) |
| * |
| * TODO executeUpdate(String sql, String[] columnNames) is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "executeUpdate", |
| args = {java.lang.String.class, java.lang.String[].class} |
| ) |
| public void testExecuteUpdate_String_StringArray() { |
| Statement st = null; |
| try { |
| String[] queries = { |
| "update zoo set name='Masha', family='cat' where id=2;", |
| "drop table if exists hutch", |
| "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));", |
| "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');", |
| "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');", |
| "create view address as select address from hutch where animal_id=2", |
| "drop view address;", "drop table hutch;" }; |
| |
| Vector<String[]> array = new Vector<String[]>(); |
| array.addElement(null); |
| array.addElement(new String[] { "", "", "", "", "", "", "", "" }); |
| array.addElement(new String[] { "field 1", "", "field2" }); |
| array.addElement(new String[] { "id", "family", "name" }); |
| array |
| .addElement(new String[] { "id", null, "family", null, |
| "name" }); |
| array.addElement(new String[] { "id", " ", "name" }); |
| array.addElement(new String[] { null, null, null, null }); |
| array.addElement(new String[] { " ", "123 21", "~!@#$%^&*()_+ ", |
| null }); |
| |
| st = conn.createStatement(); |
| for (int i = 0; i < queries.length; i++) { |
| st.executeUpdate(queries[i], (String[]) array.elementAt(i)); |
| fail("Revise test implemenation for feature impl. has changed"); |
| } |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| // fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Statement#getUpdateCount() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "SQLException test fails", |
| method = "getUpdateCount", |
| args = {} |
| ) |
| @KnownFailure("statment.close() does not wrap up") |
| public void testGetUpdateCount() { |
| Statement st = null; |
| try { |
| String query = "update zoo set name='Masha', family='cat' where id=2;"; |
| st = conn.createStatement(); |
| st.executeUpdate(query); |
| assertEquals(1, st.getUpdateCount()); |
| query = "update zoo set name='Masha', family='cat' where id=5;"; |
| st.executeUpdate(query); |
| assertEquals(0, st.getUpdateCount()); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| // statment closed : Exception test |
| try { |
| st.getUpdateCount(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#getGeneratedKeys()} |
| * |
| * TODO getGeneratedKeys() is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not supported", |
| method = "getGeneratedKeys", |
| args = {} |
| ) |
| public void testGeneratedKeys() { |
| Statement st = null; |
| try { |
| String insert = "insert into zoo (id, name, family) values (8, 'Tuzik', 'dog');"; |
| st = conn.createStatement(); |
| assertNull(st.getGeneratedKeys()); |
| fail("Fail: statement does not fail"); |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#setCursorName(String)} |
| * |
| * TODO setCursorName() is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not supported", |
| method = "setCursorName", |
| args = {java.lang.String.class} |
| ) |
| public void testSetCursorName() { |
| Statement st = null; |
| try { |
| String select = "select * from zoo"; |
| st = conn.createStatement(); |
| st.setCursorName("test"); |
| fail("Fail: statement does not fail"); |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#setEscapeProcessing} |
| * |
| * TODO setExcapeProcessing() is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not supported", |
| method = "setEscapeProcessing", |
| args = {boolean.class} |
| ) |
| public void testSetEscapeProcessing() { |
| Statement st = null; |
| try { |
| String select = "select * from zoo"; |
| st = conn.createStatement(); |
| st.setEscapeProcessing(true); |
| fail("Fail: statement does not fail"); |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| } |
| |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#setQueryTimeout} |
| * |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Error in impl. default query timeout for sqlite dbs is 0.", |
| method = "setQueryTimeout", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Error in impl. default query timeout for sqlite dbs is 0.", |
| method = "getQueryTimeout", |
| args = {} |
| ) |
| }) |
| @KnownFailure("Error in implementation either setter or getter fails. "+ |
| "Getter spec is not explicit about unit.") |
| public void testSetQueryTimeout() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.setQueryTimeout(2000); |
| assertEquals(2000, st.getQueryTimeout()); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } |
| |
| st = null; |
| try { |
| st = conn.createStatement(); |
| st.setQueryTimeout(-1); |
| fail("SQLException is not thrown"); |
| } catch (SQLException e) { |
| // expected |
| } |
| |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#getResultSetType()} |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Tests fail. not fully supported: returns only ResultSet.TYPE_SCROLL_INSENSITIVE. Either should throw an unsupported exception or behave according to spec.", |
| method = "getResultSetType", |
| args = {} |
| ) |
| @KnownFailure("not fully supported") |
| public void testGetResultSetType() { |
| Statement st = null; |
| // test default value |
| try { |
| st = conn.createStatement(); |
| st.getResultSetType(); |
| assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, st |
| .getResultSetType()); |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| } |
| |
| // failing tests |
| try { |
| st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, |
| ResultSet.CONCUR_UPDATABLE); |
| st.getResultSetType(); |
| assertEquals(ResultSet.TYPE_SCROLL_SENSITIVE, st.getResultSetType()); |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| } |
| |
| try { |
| st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, |
| ResultSet.CONCUR_UPDATABLE); |
| st.getResultSetType(); |
| assertEquals(ResultSet.TYPE_SCROLL_SENSITIVE, st.getResultSetType()); |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| } |
| |
| try { |
| st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_UPDATABLE); |
| st.getResultSetType(); |
| assertEquals(ResultSet.TYPE_FORWARD_ONLY, st.getResultSetType()); |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#getResultSetHoldability()} |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not supported", |
| method = "getResultSetHoldability", |
| args = {} |
| ) |
| @KnownFailure("Test for default value fails") |
| public void testGetResultSetHoldability() { |
| |
| // test default value |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| assertEquals(ResultSet.CLOSE_CURSORS_AT_COMMIT, st |
| .getResultSetHoldability()); |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| } |
| |
| // failing tests |
| try { |
| st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.HOLD_CURSORS_OVER_COMMIT); |
| fail("Exception expected: not supported"); |
| /* |
| st.getResultSetHoldability(); |
| assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, st |
| .getResultSetHoldability()); |
| */ |
| } catch (SQLException e) { |
| // ok: not supported |
| } |
| |
| try { |
| st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.CLOSE_CURSORS_AT_COMMIT); |
| fail("Exception expected: not supported"); |
| /* |
| st.getResultSetHoldability(); |
| assertEquals(ResultSet.CLOSE_CURSORS_AT_COMMIT, st |
| .getResultSetHoldability()); |
| */ |
| } catch (SQLException e) { |
| // ok: not supported |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#getResultSetConcurrency()} |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Tests fail. returns only ResultSet.TYPE_SCROLL_INSENSITIVE. Either should throw an unsupported exception or behave according to spec.", |
| method = "getResultSetConcurrency", |
| args = {} |
| ) |
| @KnownFailure("Not supported") |
| public void testGetResultSetConcurrency() { |
| Statement st = null; |
| |
| // test default value |
| try { |
| st = conn.createStatement(); |
| st.getResultSetConcurrency(); |
| assertEquals(ResultSet.CONCUR_READ_ONLY, st |
| .getResultSetConcurrency()); |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| } |
| |
| // failing tests |
| |
| try { |
| st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, |
| ResultSet.CONCUR_UPDATABLE); |
| st.getResultSetConcurrency(); |
| assertEquals(ResultSet.CONCUR_UPDATABLE, st.getResultSetConcurrency()); |
| fail("Exception expected: not supported"); |
| } catch (SQLException e) { |
| //ok |
| |
| } |
| |
| try { |
| st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, |
| ResultSet.CONCUR_READ_ONLY); |
| st.getResultSetConcurrency(); |
| assertEquals(ResultSet.CONCUR_READ_ONLY, st.getResultSetConcurrency()); |
| fail("Exception expected: not supported"); |
| } catch (SQLException e) { |
| //ok; |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#getResultSet()} |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Error in implementation. Is not according to spec:if updateCount > 0 resultset must be null.", |
| method = "getResultSet", |
| args = {} |
| ) |
| @KnownFailure("Does not return null on update count > 0 (not a select statement) ") |
| public void testGetResultSet() { |
| Statement st = null; |
| ResultSet res = null; |
| |
| try { |
| st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.CLOSE_CURSORS_AT_COMMIT); |
| st.execute("create table test (c1);"); |
| res = st.getResultSet(); |
| assertNull(res); |
| } catch (SQLException e) { |
| fail("Unexpected Exception "+e); |
| } |
| |
| try { |
| st = conn.createStatement(); |
| String select = "select * from zoo where id == 4;"; |
| String insert = "insert into zoo (id, name, family) values (4, 'Vorobuy', 'bear');"; |
| st.execute(insert); |
| st.execute(select); |
| assertEquals(-1, st.getUpdateCount()); |
| res = st.getResultSet(); |
| assertNotNull(res); |
| res.next(); |
| assertEquals(4,res.getInt(1)); |
| assertEquals("Vorobuy",res.getString(2)); |
| assertEquals("bear",res.getString(3)); |
| // assertEquals(0, st.getUpdateCount()); not supported |
| assertFalse(res.next()); |
| } catch (SQLException e) { |
| fail("SQLException is thrown:"+e.getMessage()); |
| } |
| |
| try { |
| st = conn.createStatement(); |
| String insert = "insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');"; |
| st |
| .execute(insert); |
| res = st.getResultSet(); |
| // statement is an update and should return null according to spec. |
| if (st.getUpdateCount() > 0) { |
| assertNull(res); |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown:"+e.getMessage()); |
| } |
| |
| try { |
| st.close(); |
| st.getResultSet(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#setQueryTimeout} |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Errors in impl.An other value is returned than was set (X * 1000)Default query timeout for sqlite dbs is 0.", |
| method = "getQueryTimeout", |
| args = {} |
| ) |
| @KnownFailure("An other value is returned than was set (X * 1000)") |
| public void testGetQueryTimeout() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.setQueryTimeout(2000); |
| assertEquals(2000, st.getQueryTimeout()); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } |
| |
| try { |
| st = conn.createStatement(); |
| assertEquals(0,st.getQueryTimeout()); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } |
| |
| try { |
| st.close(); |
| st.getQueryTimeout(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#getMoreResults()} |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not fully supported", |
| method = "getMoreResults", |
| args = {} |
| ) |
| @KnownFailure("not supported") |
| public void testGetMoreResults() { |
| Statement st = null; |
| ResultSet res1 = null; |
| ResultSet res2 = null; |
| String[] queries = { |
| "insert into zoo values (3,'John','bird');", |
| "update zoo set name='Masha', family='cat' where id=3;", |
| "update zoo set name='Masha', family='bear' where id=3;"}; |
| |
| try { |
| st = conn.createStatement(); |
| st.execute(queries[0]); |
| assertFalse(st.getMoreResults()); |
| |
| try { |
| st.getResultSet(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st.getMoreResults(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#getMoreResults(int)} |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.NOT_FEASIBLE, |
| notes = "Callable Statements are not supported", |
| method = "getMoreResults", |
| args = {int.class} |
| ) |
| public void testGetMoreResultsInt() { |
| /* |
| } catch (BatchUpdateException e) { |
| fail("Unexpected Exception "+e.getMessage()); |
| } catch (SQLException e) { |
| assertEquals("not supported",e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st.getMoreResults(Integer.MAX_VALUE); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| */ |
| } |
| |
| /** |
| * @test {@link java.sql.Statement#cancel()} |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test fails. See also SQLite.DatabaseTest test of interrupt().", |
| method = "cancel", |
| args = {} |
| ) |
| @KnownFailure("Bug in implementation of cancel: Does not fulfill spec.") |
| public void testCancel() { |
| Statement st = null; |
| try { |
| st = conn.prepareStatement("insert into zoo values (7,'Speedy Gonzales','Mouse');"); |
| |
| CancelThread c = new CancelThread(st); |
| InsertThread ins = new InsertThread((PreparedStatement)st); |
| |
| try { |
| ins.t.join(); |
| c.t.join(); |
| } catch (InterruptedException e) { |
| fail("Error in test setup: "); |
| } catch (Exception e){ |
| // Insert thread may throw an exception |
| // that it could not complete statement |
| } |
| |
| // both threads have terminated and cancel should have cancelled the insert statement. |
| ResultSet res = st.executeQuery("select * from zoo where id=7"); |
| assertFalse(res.next()); |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } |
| |
| try { |
| st.close(); |
| st.cancel(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| class CancelThread implements Runnable{ |
| Thread t; |
| Statement stmt; |
| CancelThread (Statement aSt) { |
| this.stmt = aSt; |
| t = new Thread(this,"Cancel thread"); |
| t.start(); |
| } |
| public void run() { |
| Logger.global.info("*Cancel* thread started"); |
| try { |
| Thread.sleep(1500); |
| } catch (InterruptedException e1) { |
| fail("Error in test setup"); |
| e1.printStackTrace(); |
| } |
| try { |
| Logger.global.info("*Cancel* thread, about to do stmt.cancel()"); |
| stmt.cancel(); |
| Logger.global.info("*Cancel* thread, stmt.cancel() done"); |
| } catch (SQLException e) { |
| fail("Error in test setup"); |
| e.printStackTrace(); |
| } |
| Logger.global.info("*Cancel* thread terminated"); |
| } |
| } |
| |
| class InsertThread implements Runnable{ |
| Thread t; |
| PreparedStatement stmt; |
| InsertThread (PreparedStatement aSt) { |
| this.stmt = aSt; |
| t = new Thread(this,"Insert thread"); |
| t.start(); |
| } |
| public void run() { |
| Logger.global.info("*Insert* thread started"); |
| try { |
| Thread.sleep(1500); |
| } catch (InterruptedException e1) { |
| fail("Error in test setup"); |
| e1.printStackTrace(); |
| } |
| try { |
| Logger.global.info("*Insert* thread, about to do insertion"); |
| stmt.execute(); |
| stmt.execute(); |
| Logger.global.info("*Insert* thread inserted"); |
| } catch (SQLException e) { |
| fail("Error in test setup"); |
| e.printStackTrace(); |
| } |
| Logger.global.info("*Insert* thread terminated"); |
| } |
| } |
| |
| } |