| /* |
| * 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.java.sql; |
| |
| import dalvik.annotation.KnownFailure; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetNew; |
| |
| import java.io.CharArrayReader; |
| import java.math.BigDecimal; |
| import java.sql.Connection; |
| import java.sql.Date; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| import java.sql.Time; |
| import java.util.ArrayList; |
| import java.util.Calendar; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| |
| import tests.support.DatabaseCreator; |
| import tests.support.Support_SQL; |
| import junit.extensions.TestSetup; |
| import junit.framework.Test; |
| import junit.framework.TestCase; |
| import junit.framework.TestSuite; |
| |
| @TestTargetClass(Statement.class) |
| public class SelectFunctionalityTest extends TestCase { |
| |
| private static Connection conn; |
| |
| private static Statement statement; |
| |
| private static Date date; |
| |
| private static Time time; |
| |
| public void setUp() throws Exception { |
| super.setUp(); |
| Support_SQL.loadDriver(); |
| try { |
| conn = Support_SQL.getConnection(); |
| statement = conn.createStatement(); |
| createTestTables(); |
| } catch (SQLException e) { |
| fail("Unexpected SQLException " + e.toString()); |
| } |
| } |
| |
| public void tearDown() throws Exception { |
| deleteTestTables(); |
| conn.close(); |
| statement.close(); |
| super.tearDown(); |
| } |
| |
| private void createTestTables() { |
| try { |
| ResultSet userTab = conn.getMetaData().getTables(null, |
| null, null, null); |
| |
| while (userTab.next()) { |
| String tableName = userTab.getString("TABLE_NAME"); |
| if (tableName.equals(DatabaseCreator.TEST_TABLE2)) { |
| statement.execute(DatabaseCreator.DROP_TABLE2); |
| } else if (tableName |
| .equals(DatabaseCreator.SALESPEOPLE_TABLE)) { |
| statement |
| .execute(DatabaseCreator.DROP_TABLE_SALESPEOPLE); |
| } else if (tableName |
| .equals(DatabaseCreator.CUSTOMERS_TABLE)) { |
| statement |
| .execute(DatabaseCreator.DROP_TABLE_CUSTOMERS); |
| } else if (tableName |
| .equals(DatabaseCreator.ORDERS_TABLE)) { |
| statement |
| .execute(DatabaseCreator.DROP_TABLE_ORDERS); |
| } |
| } |
| userTab.close(); |
| |
| statement.execute(DatabaseCreator.CREATE_TABLE2); |
| statement.execute(DatabaseCreator.CREATE_TABLE_SALESPEOPLE); |
| statement.execute(DatabaseCreator.CREATE_TABLE_CUSTOMERS); |
| statement.execute(DatabaseCreator.CREATE_TABLE_ORDERS); |
| |
| long currentTime = Calendar.getInstance().getTimeInMillis(); |
| date = new Date(currentTime); |
| time = new Time(currentTime); |
| |
| DatabaseCreator.fillTestTable2(conn, 1, 5, currentTime); |
| DatabaseCreator.fillCustomersTable(conn); |
| DatabaseCreator.fillOrdersTable(conn); |
| DatabaseCreator.fillSalesPeopleTable(conn); |
| |
| } catch (SQLException e) { |
| fail("Unexpected SQLException " + e.toString()); |
| } |
| } |
| |
| private void deleteTestTables() { |
| try { |
| statement.execute(DatabaseCreator.DROP_TABLE2); |
| statement.execute(DatabaseCreator.DROP_TABLE_SALESPEOPLE); |
| statement.execute(DatabaseCreator.DROP_TABLE_CUSTOMERS); |
| statement.execute(DatabaseCreator.DROP_TABLE_ORDERS); |
| } catch (SQLException e) { |
| fail("Unexpected SQLException " + e.toString()); |
| } |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectSimple(). Selects all records |
| * from the table |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects all records from the table", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SelectSimple() throws SQLException { |
| String sql = "SELECT * FROM " + DatabaseCreator.TEST_TABLE2; |
| ResultSet result = statement.executeQuery(sql); |
| int counter = 0; |
| |
| while (result.next()) { |
| int id = result.getInt("finteger"); |
| assertEquals("expected value doesn't equal actual", |
| DatabaseCreator.defaultString + id, result |
| .getString("ftext")); |
| assertEquals("expected value doesn't equal actual", |
| DatabaseCreator.defaultCharacter + id, result |
| .getString("fcharacter")); |
| |
| // TODO getBigDecimal is not supported |
| // assertEquals("expected value doesn't equal actual", BigDecimal |
| // .valueOf(id + 0.1), result.getBigDecimal("fdecimal")); |
| // assertEquals("expected value doesn't equal actual", BigDecimal |
| // .valueOf(id + 0.1), result.getBigDecimal("fnumeric")); |
| // assertEquals("expected value doesn't equal actual", id, result |
| // .getInt("fsmallint")); |
| assertEquals("expected value doesn't equal actual", BigDecimal |
| .valueOf(id + 0.1).floatValue(), result.getFloat("ffloat")); |
| assertEquals("expected value doesn't equal actual", BigDecimal |
| .valueOf(id + 0.1).doubleValue(), result.getDouble("freal")); |
| assertEquals("expected value doesn't equal actual", BigDecimal |
| .valueOf(id + 0.1).doubleValue(), result |
| .getDouble("fdouble")); |
| assertEquals("expected value doesn't equal actual", |
| date.toString(), result.getDate("fdate").toString()); |
| assertEquals("expected value doesn't equal actual", |
| time.toString(), result.getTime("ftime").toString()); |
| counter++; |
| } |
| |
| assertEquals("number of rows in ResultSet is wrong", 5, counter); |
| result.close(); |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectPrepared(). Selects all records |
| * from the table using parametric query |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects all records from the table using parametric query", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SelectPrepared() throws SQLException { |
| String sql = "SELECT finteger, ftext, fcharacter, fdecimal, fnumeric," |
| + " fsmallint, ffloat, freal, fdouble, fdate, ftime" + " FROM " |
| + DatabaseCreator.TEST_TABLE2 |
| + " WHERE finteger = ? AND ftext = ? AND fcharacter = ? AND" |
| + " fdecimal = ? AND fnumeric = ? AND fsmallint = ? AND" |
| + " freal = ? AND fdouble = ? AND fdate = ?" + " AND ftime = ?"; |
| PreparedStatement prepStatement = conn.prepareStatement(sql); |
| |
| CharArrayReader reader = new CharArrayReader(new String( |
| DatabaseCreator.defaultCharacter + "1").toCharArray()); |
| prepStatement.setInt(1, 1); |
| prepStatement.setString(2, DatabaseCreator.defaultString + "1"); |
| // TODO setCharacterStream and setBigDecimal are not supported |
| // prepStatement.setCharacterStream(3, reader, 4); |
| // prepStatement.setBigDecimal(4, BigDecimal.valueOf(1.1)); |
| // prepStatement.setBigDecimal(5, BigDecimal.valueOf(1.1)); |
| prepStatement.setInt(6, 1); |
| prepStatement.setDouble(7, 1.1); |
| prepStatement.setDouble(8, 1.1); |
| prepStatement.setDate(9, date); |
| prepStatement.setTime(10, time); |
| |
| int counter = 0; |
| ResultSet result = prepStatement.executeQuery(); |
| while (result.next()) { |
| int id = result.getInt("finteger"); |
| assertEquals("expected value doesn't equal actual", |
| DatabaseCreator.defaultString + id, result |
| .getString("ftext")); |
| assertEquals("expected value doesn't equal actual", |
| DatabaseCreator.defaultCharacter + id, result |
| .getString("fcharacter")); |
| // TODO getBigDecimal is not supported |
| // assertEquals("expected value doesn't equal actual", BigDecimal |
| // .valueOf(1.1), result.getBigDecimal("fdecimal")); |
| // assertEquals("expected value doesn't equal actual", BigDecimal |
| // .valueOf(1.1), result.getBigDecimal("fnumeric")); |
| assertEquals("expected value doesn't equal actual", id, result |
| .getInt("fsmallint")); |
| assertEquals("expected value doesn't equal actual", |
| (float) (id + 0.1), result.getFloat("ffloat")); |
| assertEquals("expected value doesn't equal actual", |
| (double) (id + 0.1), result.getDouble("freal")); |
| assertEquals("expected value doesn't equal actual", |
| (double) (id + 0.1), result.getDouble("fdouble")); |
| assertEquals("expected value doesn't equal actual", |
| date.toString(), result.getDate("fdate").toString()); |
| assertEquals("expected value doesn't equal actual", |
| time.toString(), result.getTime("ftime").toString()); |
| counter++; |
| } |
| // TODO query wasn't executed due to "not supported" methods |
| // assertEquals("number of rows in ResultSet is wrong", 1, counter); |
| prepStatement.close(); |
| result.close(); |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SubSelect(). Selects records from the |
| * table using subselect |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects records from the table using subselect", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SubSelect() throws SQLException { |
| String sql = "SELECT finteger," + " (SELECT ftext FROM " |
| + DatabaseCreator.TEST_TABLE2 + " WHERE finteger = 1) as ftext" |
| + " FROM " + DatabaseCreator.TEST_TABLE2; |
| ResultSet result = statement.executeQuery(sql); |
| |
| HashMap<Integer, String> value = new HashMap<Integer, String>(); |
| value.put(1, DatabaseCreator.defaultString + "1"); |
| value.put(2, DatabaseCreator.defaultString + "1"); |
| value.put(3, DatabaseCreator.defaultString + "1"); |
| value.put(4, DatabaseCreator.defaultString + "1"); |
| value.put(5, DatabaseCreator.defaultString + "1"); |
| |
| while (result.next()) { |
| int key = result.getInt("finteger"); |
| String val = result.getString("ftext"); |
| assertTrue("wrong value of finteger field", value.containsKey(key)); |
| assertEquals("wrong value of ftext field", value.get(key), val); |
| value.remove(key); |
| } |
| assertTrue("expected rows number doesn't equal actual rows number", |
| value.isEmpty()); |
| result.close(); |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectThreeTables(). Selects records |
| * from a few tables |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects records from a few tables", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SelectThreeTables() throws SQLException { |
| String sql = "SELECT onum, " + DatabaseCreator.ORDERS_TABLE + ".cnum" |
| + " FROM " + DatabaseCreator.SALESPEOPLE_TABLE + ", " |
| + DatabaseCreator.CUSTOMERS_TABLE + ", " |
| + DatabaseCreator.ORDERS_TABLE + " WHERE " |
| + DatabaseCreator.CUSTOMERS_TABLE + ".city <> " |
| + DatabaseCreator.SALESPEOPLE_TABLE + ".city" + " AND " |
| + DatabaseCreator.ORDERS_TABLE + ".cnum = " |
| + DatabaseCreator.CUSTOMERS_TABLE + ".cnum" + " AND " |
| + DatabaseCreator.ORDERS_TABLE + ".snum = " |
| + DatabaseCreator.SALESPEOPLE_TABLE + ".snum"; |
| ResultSet result = statement.executeQuery(sql); |
| |
| HashMap<Integer, Integer> value = new HashMap<Integer, Integer>(); |
| value.put(3001, 2008); |
| value.put(3002, 2007); |
| value.put(3006, 2008); |
| value.put(3009, 2002); |
| value.put(3007, 2004); |
| value.put(3010, 2004); |
| |
| while (result.next()) { |
| int key = result.getInt("onum"); |
| int val = result.getInt("cnum"); |
| assertTrue("wrong value of onum field", value.containsKey(key)); |
| assertEquals("wrong value of cnum field", value.get(key), |
| (Integer) val); |
| value.remove(key); |
| } |
| assertTrue("expected rows number doesn't equal actual rows number", |
| value.isEmpty()); |
| result.close(); |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectThreeTables(). Selects records |
| * from a table using union |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects records from a table using union", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SelectUnionItself() throws SQLException { |
| String sql = "SELECT b.cnum, b.cname" + " FROM " |
| + DatabaseCreator.CUSTOMERS_TABLE + " a, " |
| + DatabaseCreator.CUSTOMERS_TABLE + " b" |
| + " WHERE a.snum = 1002" + " AND b.city = a.city"; |
| ResultSet result = statement.executeQuery(sql); |
| |
| HashMap<Integer, String> value = new HashMap<Integer, String>(); |
| value.put(2003, "Liu"); |
| value.put(2004, "Grass"); |
| value.put(2008, "Cisneros"); |
| |
| while (result.next()) { |
| int key = result.getInt("cnum"); |
| String val = result.getString("cname"); |
| assertTrue("wrong value of cnum field", value.containsKey(key)); |
| assertEquals("wrong value of cname field", value.get(key), val); |
| value.remove(key); |
| } |
| assertTrue("expected rows number doesn't equal actual rows number", |
| value.isEmpty()); |
| result.close(); |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectLeftOuterJoin(). Selects |
| * records from a table using left join |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects records from a table using left join", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SelectLeftOuterJoin() throws SQLException { |
| String sql = "SELECT distinct s.snum as ssnum, c.snum as ccnum FROM " |
| + DatabaseCreator.CUSTOMERS_TABLE + " c left outer join " |
| + DatabaseCreator.SALESPEOPLE_TABLE + " s on s.snum=c.snum"; |
| ResultSet result = statement.executeQuery(sql); |
| |
| HashMap<Integer, Integer> value = new HashMap<Integer, Integer>(); |
| value.put(1001, 1001); |
| value.put(1002, 1002); |
| value.put(1003, 1003); |
| value.put(1004, 1004); |
| value.put(1007, 1007); |
| |
| while (result.next()) { |
| int key = result.getInt("ssnum"); |
| Object val = result.getObject("ccnum"); |
| assertTrue("wrong value of ssnum field", value.containsKey(key)); |
| assertEquals("wrong value of ccnum field", value.get(key), |
| (Integer) val); |
| value.remove(key); |
| } |
| assertTrue("expected rows number doesn't equal actual rows number", |
| value.isEmpty()); |
| result.close(); |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectRightOuterJoin(). Selects |
| * records from a table using right join |
| * |
| * TODO RIGHT and FULL OUTER JOINs are not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "tests right outer joins. RIGHT and FULL OUTER JOINs are not supported", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| @KnownFailure("not supported") |
| public void test_SelectRightOuterJoin() throws SQLException { |
| String sql = "SELECT distinct s.snum as ssnum, c.snum as ccnum FROM " |
| + DatabaseCreator.CUSTOMERS_TABLE + " c right outer join " |
| + DatabaseCreator.SALESPEOPLE_TABLE + " s on s.snum=c.snum"; |
| ResultSet result = statement.executeQuery(sql); |
| |
| HashMap<Integer, Integer> value = new HashMap<Integer, Integer>(); |
| value.put(1001, 1001); |
| value.put(1002, 1002); |
| value.put(1003, 1003); |
| value.put(1004, 1004); |
| value.put(1007, 1007); |
| value.put(1013, null); |
| |
| while (result.next()) { |
| int key = result.getInt("ssnum"); |
| Object val = result.getObject("ccnum"); |
| assertTrue("wrong value of ssnum field", value.containsKey(key)); |
| assertEquals("wrong value of ccnum field", value.get(key), |
| (Integer) val); |
| value.remove(key); |
| } |
| assertTrue("expected rows number doesn't equal actual rows number", |
| value.isEmpty()); |
| result.close(); |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectGroupBy(). Selects records from |
| * a table using group by |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects records from a table using group by", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SelectGroupBy() throws SQLException { |
| String selectQuery = "SELECT rating, SUM(snum) AS sum FROM " |
| + DatabaseCreator.CUSTOMERS_TABLE + " GROUP BY rating"; |
| ResultSet result = statement.executeQuery(selectQuery); |
| |
| HashMap<Integer, Integer> values = new HashMap<Integer, Integer>(); |
| values.put(100, 3006); |
| values.put(200, 2005); |
| values.put(300, 2009); |
| |
| while (result.next()) { |
| int rating = result.getInt("rating"); |
| int sum = result.getInt("sum"); |
| assertTrue("Wrong value of rating field", values |
| .containsKey(rating)); |
| assertEquals("Wrong value of sum field", values.get(rating), |
| new Integer(sum)); |
| assertEquals(new Integer(sum), values.remove(rating)); |
| } |
| result.close(); |
| assertTrue("Result set has wrong size", values.isEmpty()); |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectOrderBy(). Selects records from |
| * a table using order by |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects records from a table using order by", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SelectOrderBy() throws SQLException { |
| String selectQuery = "SELECT onum FROM " + DatabaseCreator.ORDERS_TABLE |
| + " ORDER BY onum"; |
| ResultSet result = statement.executeQuery(selectQuery); |
| |
| ArrayList<Integer> values = new ArrayList<Integer>(); |
| values.add(Integer.valueOf(3001)); |
| values.add(Integer.valueOf(3002)); |
| values.add(Integer.valueOf(3003)); |
| values.add(Integer.valueOf(3005)); |
| values.add(Integer.valueOf(3006)); |
| values.add(Integer.valueOf(3007)); |
| values.add(Integer.valueOf(3008)); |
| values.add(Integer.valueOf(3009)); |
| values.add(Integer.valueOf(3010)); |
| values.add(Integer.valueOf(3011)); |
| |
| int index = 0; |
| while (result.next()) { |
| Integer onum = result.getInt("onum"); |
| assertTrue("result set doesn't contain value", values |
| .contains(onum)); |
| assertEquals("result set is not sorted", index, values |
| .indexOf(onum)); |
| index++; |
| } |
| result.close(); |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectDistinct(). Selects records |
| * from a table using distinct |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects records from a table using distinct", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SelectDistinct() throws SQLException { |
| String selectQuery = "SELECT DISTINCT rating FROM " |
| + DatabaseCreator.CUSTOMERS_TABLE; |
| ResultSet result = statement.executeQuery(selectQuery); |
| |
| HashSet<Integer> values = new HashSet<Integer>(); |
| values.add(Integer.valueOf(100)); |
| values.add(Integer.valueOf(200)); |
| values.add(Integer.valueOf(300)); |
| |
| while (result.next()) { |
| Integer rating = result.getInt("rating"); |
| assertTrue("result set doesn't contain value", values |
| .contains(rating)); |
| assertTrue("wrong value in the result set", values.remove(rating)); |
| } |
| result.close(); |
| assertTrue("Result set has wrong size", values.isEmpty()); |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectAgregateFunctions(). Selects |
| * records from a table using agregate functions |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects records from a table using agregate functions", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SelectAgregateFunctions() throws SQLException { |
| String selectCount = "SELECT count(onum) as count FROM " |
| + DatabaseCreator.ORDERS_TABLE; |
| String selectSum = "SELECT sum(onum) as sum FROM " |
| + DatabaseCreator.ORDERS_TABLE; |
| String selectAvg = "SELECT avg(onum) as avg FROM " |
| + DatabaseCreator.ORDERS_TABLE; |
| String selectMax = "SELECT max(onum) as max FROM " |
| + DatabaseCreator.ORDERS_TABLE; |
| String selectMin = "SELECT min(onum) as min FROM " |
| + DatabaseCreator.ORDERS_TABLE; |
| |
| func("count", selectCount, 10); |
| func("sum", selectSum, 30062); |
| func("avg", selectAvg, 3006); |
| func("max", selectMax, 3011); |
| func("min", selectMin, 3001); |
| } |
| |
| private void func(String name, String query, int expected) { |
| int res = 0; |
| double resDouble = 0.0; |
| try { |
| ResultSet result = statement.executeQuery(query); |
| while (result.next()) { |
| res = result.getInt(name); |
| if (res != 0 ) { |
| assertEquals(expected,res); |
| break; |
| } |
| // for Double: getInt not supported yet |
| resDouble = Double.parseDouble(result.getString(name)); |
| res = (int) Math.rint(resDouble); |
| assertEquals(expected,res); |
| |
| } |
| assertFalse("wrong size of result set", result.next()); |
| result.close(); |
| } catch (SQLException e) { |
| fail(e.getMessage()); |
| } |
| } |
| |
| /** |
| * @tests SelectFunctionalityTest#test_SelectHaving(). Selects records from |
| * a table using having |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Functionality test: Selects records from a table using having", |
| method = "executeQuery", |
| args = {java.lang.String.class} |
| ) |
| public void test_SelectHaving() throws SQLException { |
| String selectQuery = "SELECT snum, max(amt) AS max FROM " |
| + DatabaseCreator.ORDERS_TABLE |
| + " GROUP BY snum HAVING max(amt) > 3000"; |
| ResultSet result = statement.executeQuery(selectQuery); |
| |
| HashSet<Double> values = new HashSet<Double>(); |
| values.add(Double.valueOf(9891.88)); |
| values.add(Double.valueOf(5160.45)); |
| |
| while (result.next()) { |
| Double max = result.getDouble("max"); |
| assertTrue("result set doesn't contain value", values.contains(max)); |
| assertTrue("wrong value in the result set", values.remove(max)); |
| } |
| result.close(); |
| assertTrue("Result set has wrong size", values.isEmpty()); |
| } |
| } |