db-derby-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davi...@apache.org
Subject svn commit: r378045 [2/2] - in /db/derby/code/trunk/java: engine/org/apache/derby/impl/sql/execute/ testing/org/apache/derbyTesting/functionTests/harness/ testing/org/apache/derbyTesting/functionTests/master/ testing/org/apache/derbyTesting/functionTes...
Date Wed, 15 Feb 2006 18:18:51 GMT
Added: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURBaseTest.java
URL: http://svn.apache.org/viewcvs/db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURBaseTest.java?rev=378045&view=auto
==============================================================================
--- db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURBaseTest.java (added)
+++ db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURBaseTest.java Wed Feb 15 10:18:47 2006
@@ -0,0 +1,305 @@
+/*
+ *
+ * Derby - Class SURBaseTest
+ *
+ * Copyright 2006 The Apache Software Foundation or its 
+ * licensors, as applicable.
+ *
+ * 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 org.apache.derbyTesting.functionTests.tests.jdbcapi;
+import org.apache.derbyTesting.functionTests.util.DerbyJUnitTest;
+import org.apache.derbyTesting.functionTests.util.TestUtil;
+import org.apache.derby.tools.ij;
+import junit.framework.*;
+import java.sql.*;
+import java.util.Properties;
+
+/**
+ * Base class for testing Scrollable Updatable ResultSets. 
+ * The setUp() provides a Connection to the database.
+ * 
+ * Tests of this class needs to be decorated by a DBSetup
+ * and SURDataModelSetup.
+ * 
+ * @author Andreas Korneliussen 
+ */
+abstract public class SURBaseTest extends TestCase {
+    
+    /** Creates a new instance of SURBaseTest */
+    public SURBaseTest(String name) {
+        super(name);
+    }
+    
+    /**
+     * Get a JDBC Connection to the Derby database.
+     * The autocommit flag is set to false, and the isolation level
+     * for the transactions is set to repeatable read.
+     */
+    protected Connection getNewConnection() 
+        throws SQLException
+    {
+        final Connection rcon = getConnection();
+        rcon.setAutoCommit(false);
+        rcon.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
+        return rcon;
+    }
+
+    static Connection getConnection() 
+        throws SQLException
+    {
+        String url = TestUtil.getJdbcUrlPrefix() + "wombat;create=true";
+        return DriverManager.getConnection(url);        
+    }
+    
+    /**
+     * Set up the connection to the database.
+     */
+    public void setUp() throws  Exception {       
+        println("SetUp");
+        TestUtil.loadDriver();
+        con = getNewConnection();
+    }
+    
+    /**
+     * Rollback the transaction
+     */
+    public void tearDown() throws Exception {
+        println("TearDown");
+        try { 
+            con.rollback();
+            con.close();
+        } catch (SQLException e) {
+            printStackTrace(e);
+        }      
+    }
+    
+    /**
+     * Verify the data of a tuple in the ResultSet, based on the data 
+     * that were inserted.
+     */
+    protected void verifyTuple(ResultSet rs) throws SQLException {
+        int id = rs.getInt(1);
+        int a = rs.getInt(2);
+        int b = rs.getInt(3);
+        int sum = a + id + 17;
+        println("Reading tuple:(" + id + "," + a  + "," + b + ",'" + 
+                rs.getString(4) + "')");
+        assertEquals("Expecting b==id+a+17, got: id=" + id + 
+                     ",a=" + a + ",b=" + b + ",c=" +rs.getString(4), b, sum);
+    }
+    
+    /**
+     * Update the current tuple in the ResultSet using updateXXX() and 
+     * updateRow()
+     */
+    protected void updateTuple(ResultSet rs) throws SQLException {
+        assertTrue("Cannot use updateRow() in autocommit mode", 
+                   !con.getAutoCommit());
+        int id = rs.getInt(1);
+        int a = rs.getInt(2);
+        int b = rs.getInt(3);        
+        int newA = a*2 +id + 37;
+        int newB = newA + id + 17;
+        println("Updating record (" + id + "," + newA + "," + newB + ")");
+        rs.updateInt(2, newA);
+        rs.updateInt(3, newB); 
+        rs.updateRow();
+    }
+    
+    /**
+     * Update the current tuple in the ResultSet using positioned update
+     */
+    protected void updateTuplePositioned(ResultSet rs) throws SQLException {
+        int id = rs.getInt(1);
+        int a = rs.getInt(2);
+        int b = rs.getInt(3);        
+        int newA = a*2 +id + 37;
+        int newB = newA + id + 17;
+        PreparedStatement ps = con.
+            prepareStatement("update T1 set a=?,b=? where current of " +
+                             rs.getCursorName());
+        ps.setInt(1, newA);
+        ps.setInt(2, newB);
+        assertEquals("Expected one tuple to be updated", 1, ps.executeUpdate());
+    }
+    
+    /**
+     * Scroll forward to the end of the ResultSet, and verify tuples while 
+     * scrolling. 
+     */
+    protected void scrollForward(ResultSet rs) throws SQLException
+    {        
+        boolean ignoreCount = rs.getType()==ResultSet.TYPE_FORWARD_ONLY 
+            || !rs.isBeforeFirst();
+        int nRecords = 0; 
+        while (rs.next()) {
+            nRecords++;
+            verifyTuple(rs);
+        }
+        if (!ignoreCount) {
+            assertEquals("Expected  " + recordCount + " records", nRecords, 
+                         recordCount);
+        }
+    }
+    
+    /**
+     * Scroll backward to the beginning of the ResultSet, and verify tuples 
+     * while scrolling.
+     */
+    protected void scrollBackward(ResultSet rs) throws SQLException
+    {
+        boolean ignoreCount = rs.getType()==ResultSet.TYPE_FORWARD_ONLY 
+            || !rs.isAfterLast();
+        
+        int nRecords = 0; 
+        while (rs.previous()) {
+            nRecords++;
+            verifyTuple(rs);
+        }
+        if (!ignoreCount) {
+            assertEquals("Expected  " + recordCount + " records", nRecords, 
+                         recordCount);
+        }
+    }
+    
+    /**
+     * Scroll forward and update the tuples using updateXXX() and updateRow()
+     */
+    protected void scrollForwardAndUpdate(ResultSet rs) throws SQLException
+    {
+        int nRecords = 0; 
+        boolean ignoreCount = rs.getType()==ResultSet.TYPE_FORWARD_ONLY 
+            || !rs.isBeforeFirst();
+        
+        while (rs.next()) {
+            nRecords++;
+            verifyTuple(rs);
+            updateTuple(rs);
+        }
+        if (!ignoreCount) {
+            assertEquals("Expected  " + recordCount + " records", nRecords, 
+                         recordCount);
+        }
+        assertNotNull("rs.getCursorName()", rs.getCursorName());
+    }
+    
+    /**
+     * Scroll forward and do positioned updates.
+     */
+    protected void scrollForwardAndUpdatePositioned(ResultSet rs) 
+        throws SQLException
+    {
+        int nRecords = 0; 
+        boolean ignoreCount = rs.getType()==ResultSet.TYPE_FORWARD_ONLY 
+            || !rs.isBeforeFirst();
+        while (rs.next()) {
+            nRecords++;
+            verifyTuple(rs);
+            updateTuplePositioned(rs);
+        }
+        if (!ignoreCount) {
+            assertEquals("Expected  " + recordCount + " records", nRecords, 
+                         recordCount);
+        }
+        assertNotNull("rs.getCursorName()", rs.getCursorName());
+    }
+    
+    /**
+     * Scroll backward and update the records using updateXXX() and updateRow()
+     */
+    protected void scrollBackwardAndUpdate(ResultSet rs) throws SQLException
+    {
+        int nRecords = 0; 
+        boolean ignoreCount = rs.getType()==ResultSet.TYPE_FORWARD_ONLY 
+            || !rs.isAfterLast();
+        while (rs.previous()) {
+            nRecords++;
+            verifyTuple(rs);
+            updateTuple(rs);
+        }
+        if (!ignoreCount) {
+            assertEquals("Expected  " + recordCount + " records", nRecords, 
+                         recordCount);
+        }
+        assertNotNull("rs.getCursorName()", rs.getCursorName());
+    }
+    
+    /**
+     * Scroll backward and update the records using positioned updates.
+     */
+    protected void scrollBackwardAndUpdatePositioned(ResultSet rs) 
+        throws SQLException
+    {
+        int nRecords = 0; 
+        boolean ignoreCount = rs.getType()==ResultSet.TYPE_FORWARD_ONLY 
+            || !rs.isAfterLast();
+        while (rs.previous()) {
+            nRecords++;
+            verifyTuple(rs);
+            updateTuplePositioned(rs);
+        }
+        if (!ignoreCount) {
+            assertEquals("Expected  " + recordCount + " records", nRecords, 
+                         recordCount);
+        }
+        assertNotNull("rs.getCursorName()", rs.getCursorName());
+    }
+    
+    /**
+     * Assert that update of ResultSet fails with a SQLException
+     * due to read-only ResultSet.
+     */
+    protected void assertFailOnUpdate(ResultSet rs) 
+        throws SQLException
+    {
+        boolean failedCorrect = false;
+        try {
+            updateTuple(rs);
+        } catch (SQLException e) {
+            failedCorrect = true;
+            assertEquals("Unexpected SQL state", 
+                         RESULTSET_NOT_UPDATABLE_SQL_STATE, 
+                         e.getSQLState());
+            
+        }
+        assertTrue("Expected cursor to fail on update, since it is read only", 
+                   failedCorrect);
+    }
+    
+    protected Connection con = null; // Connection established in setUp()
+    final static int recordCount = SURDataModelSetup.recordCount;  
+    
+       
+    /**
+     * Error codes and SQL state
+     */
+    final static String FOR_UPDATE_NOT_PERMITTED_SQL_STATE = "42Y90";
+    final static String CURSOR_NOT_UPDATABLE_SQL_STATE = "42X23";
+    final static String RESULTSET_NOT_UPDATABLE_SQL_STATE = "XJ083";
+    final static String LOCK_TIMEOUT_SQL_STATE = "40XL1";
+    final static String LOCK_TIMEOUT_EXPRESSION_SQL_STATE = "38000";
+    
+    static void println(String text) {
+        DerbyJUnitTest.println(text);
+    }
+    
+    /**
+     * Prints the stack trace. If run in the harness, the
+     * harness will mark the test as failed if this method
+     * has been called.
+     */
+    static void printStackTrace(Throwable t) {
+        DerbyJUnitTest.printStackTrace(t);
+    }
+}

Propchange: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURBaseTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURDataModelSetup.java
URL: http://svn.apache.org/viewcvs/db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURDataModelSetup.java?rev=378045&view=auto
==============================================================================
--- db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURDataModelSetup.java (added)
+++ db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURDataModelSetup.java Wed Feb 15 10:18:47 2006
@@ -0,0 +1,263 @@
+/*
+ *
+ * Derby - Class SURDataModelSetup
+ *
+ * Copyright 2006 The Apache Software Foundation or its 
+ * licensors, as applicable.
+ *
+ * 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 org.apache.derbyTesting.functionTests.tests.jdbcapi;
+import org.apache.derbyTesting.functionTests.util.DerbyJUnitTest;
+import org.apache.derbyTesting.functionTests.util.TestUtil;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import java.util.Set;
+import java.util.Iterator;
+import java.util.HashSet;
+import java.util.Arrays;
+import java.util.Collections;
+
+/**
+ * This class is a decorator for the Scrollable Updatable Resultset
+ * tests.  It sets up a datamodel and populates it with data.
+ * @author Andreas Korneliussen
+ */
+public class SURDataModelSetup extends TestSetup
+{
+    /**
+     * Constructor.
+     * @param test test to decorate with this setup
+     * @param model enumerator for which model to use.
+     * (Alternatively we could use a subclass for each model)
+     */
+    public SURDataModelSetup(Test test, SURDataModel model) {
+        super(test);
+        this.model = model;       
+    }
+    
+    /**
+     * Creates a datamodel for testing Scrollable Updatable ResultSets
+     * and populates the database model with data.
+     * @param model enumerator for which model to use
+     * @param con connection to database
+     */
+    public static void createDataModel(SURDataModel model, Connection con) 
+        throws SQLException
+    {
+        try { 
+            con.createStatement().execute("drop table t1"); 
+        } catch (SQLException e) {
+            assertEquals("'drop table t1' failed with unexpected SQL State",
+                         TABLE_EXISTS_SQL_STATE, e.getSQLState());
+            
+            // The net framework does not give any valuable error code
+            if (TestUtil.isNetFramework()) {
+                
+                assertEquals("'drop table t1' failed with unexpected error code",
+                             NET_ERROR, e.getErrorCode());
+            } else {
+                assertEquals("'drop table t1' failed with unexpected error code",
+                             TABLE_EXISTS_ERRORCODE, e.getErrorCode());
+            }
+            
+        };
+        
+        Statement statement = con.createStatement();
+        
+        /** Create the table */
+        statement.execute(model.getCreateTableStatement());
+        println(model.getCreateTableStatement());
+        
+        /** Create secondary index */
+        if (model.hasSecondaryKey()) {
+            statement.execute("create index a_on_t on t1(a)");
+            println("create index a_on_t on t1(a)");
+        }
+        
+        /** Populate with data */
+        PreparedStatement ps = con.
+            prepareStatement("insert into t1 values (?,?,?,?)");
+        
+        for (int i=0; i<recordCount; i++) {
+            ps.setInt(1, i);
+            ps.setInt(2, i);
+            ps.setInt(3, i*2 + 17);
+            ps.setString(4, "Tuple " +i);
+            ps.addBatch();
+        }
+        ps.executeBatch();
+        con.commit();
+    }
+    
+    /**
+     * Creates a datamodel for testing Scrollable Updatable ResultSets
+     * and populates the database model with data.
+     */
+    public void setUp() throws  Exception {       
+        TestUtil.loadDriver();
+        println("Setting up datamodel: " + model);
+        try {
+            con = getNewConnection();
+            createDataModel(model, con);
+        } catch (SQLException e) {
+            printStackTrace(e); // Print the entire stack
+            throw e;
+        }
+    }
+    
+    /**
+     * Delete the datamodel
+     */
+    public void tearDown() 
+        throws Exception
+    {
+        try {
+            con.rollback();
+            con.createStatement().execute("drop table t1");
+            con.commit();
+            con.close();
+        } catch (SQLException e) {
+            printStackTrace(e);
+        }
+    }
+    
+    public String toString() {
+        return "SURDataModel tests with model: " + model;
+    }
+
+    /**
+     * Get a JDBC Connection to the Derby database
+     */
+    private Connection getNewConnection() 
+        throws SQLException
+    {
+        final Connection rcon = SURBaseTest.getConnection();
+        rcon.setAutoCommit(false);
+        return rcon;
+    }
+
+    private Connection con = null;
+    private final SURDataModel model;
+    final static int recordCount = 10;  // Number of records in data model.  
+        
+    /**
+     * Enum for the layout of the data model
+     */
+    public final static class SURDataModel {
+
+        /** Model with no keys */
+        public final static SURDataModel MODEL_WITH_NO_KEYS = 
+            new SURDataModel("NO_KEYS");
+        
+        /** Model with primary key */
+        public final static SURDataModel MODEL_WITH_PK = 
+            new SURDataModel("PK");
+        
+        /** Model with secondary index */
+        public final static SURDataModel MODEL_WITH_SECONDARY_KEY = 
+            new SURDataModel("SECONDARY_KEY");
+        
+        /** Model with primary key and secondary index */
+        public final static SURDataModel MODEL_WITH_PK_AND_SECONDARY_KEY = 
+            new SURDataModel("PK_AND_SECONDARY_KEY");
+
+        /** Array with all values */
+        private final static Set values = Collections.unmodifiableSet
+            (new HashSet((Arrays.asList(new SURDataModel[] {
+                MODEL_WITH_NO_KEYS, 
+                MODEL_WITH_PK, 
+                MODEL_WITH_SECONDARY_KEY,
+                MODEL_WITH_PK_AND_SECONDARY_KEY
+            }))));
+        
+        /**
+         * Returns an unmodifyable set of all valid data models
+         */ 
+        public final static Set values() {
+            return values;
+        }
+       
+
+        /** Returns true if this model has primary key */
+        public boolean hasPrimaryKey() {
+            return (this==MODEL_WITH_PK || 
+                    this==MODEL_WITH_PK_AND_SECONDARY_KEY);
+        }
+        
+        /** Returns true if this model has a secondary key */
+        public boolean hasSecondaryKey() {
+            return (this==MODEL_WITH_SECONDARY_KEY || 
+                    this==MODEL_WITH_PK_AND_SECONDARY_KEY);
+        }
+
+        /**
+         * Returns the string for creating the table
+         */
+        public String getCreateTableStatement() {
+            return hasPrimaryKey() 
+                ? "create table t1 (id int primary key, a int, b int, c varchar(5000))"
+                : "create table t1 (id int, a int, b int, c varchar(5000))";
+        }
+
+        /**
+         * Returns a string representation of the model 
+         * @return string representation of this object
+         */
+        public String toString() {
+            return name;
+        }
+        
+        /**
+         * Constructor
+         */
+        private SURDataModel(String name) {
+            this.name = name;
+        }
+        
+        
+        
+        private final String name;
+    }
+
+    /**
+     * <p>
+     * Debug code to print chatty informational messages.
+     * </p>
+     */
+    public static void println(String text)
+    {
+        DerbyJUnitTest.println(text);
+    }
+    
+    /**
+     * Prints the stack trace. If run in the harness, the
+     * harness will mark the test as failed if this method
+     * has been called.
+     */
+    static void printStackTrace(Throwable t) {
+        DerbyJUnitTest.printStackTrace(t);
+    }
+    
+    /**
+     * Error codes and SQL state
+     */
+    private final static String TABLE_EXISTS_SQL_STATE = "42Y55";
+    private final static int TABLE_EXISTS_ERRORCODE = 20000;
+    private final static int NET_ERROR = -1; 
+}

Propchange: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURDataModelSetup.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURQueryMixTest.java
URL: http://svn.apache.org/viewcvs/db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURQueryMixTest.java?rev=378045&view=auto
==============================================================================
--- db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURQueryMixTest.java (added)
+++ db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURQueryMixTest.java Wed Feb 15 10:18:47 2006
@@ -0,0 +1,554 @@
+/*
+ *
+ * Derby - Class SURQueryMixTest
+ *
+ * Copyright 2006 The Apache Software Foundation or its
+ * licensors, as applicable.
+ *
+ * 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 org.apache.derbyTesting.functionTests.tests.jdbcapi;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.PreparedStatement;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * Tests for Scrollable Updatable ResultSet (SUR). This TestCase tests
+ * scrolling (navigation), updates (using updateXXX() and updateRow() or
+ * positioned updates), deletion of records (using deleteRow() or positioned 
+ * deletes) of ResultSets.
+ * @author Andreas Korneliussen
+ */
+public class SURQueryMixTest extends SURBaseTest
+{
+    /**
+     * Constructor
+     * @param name model name of data model for this TestCase
+     * @param query to use for producing the resultset
+     * @param cursorName name of cursor
+     * @param positioned flag to determine if the Test should use positioned
+     *        updates/deletes instead of updateRow() and deleteRow()
+     */
+    public SURQueryMixTest(final String model, final String query, 
+                           final String cursorName, final boolean positioned) 
+    {
+        super("SURQueryMixTest{Model=" + model + ",Query=" +query + ",Cursor=" 
+                + cursorName + ",Positioned=" + positioned + "}");
+        this.query = query;
+        this.cursorName = cursorName;
+        this.positioned = positioned;
+        this.checkRowUpdated = false;
+        this.checkRowDeleted = false;
+    }
+
+    /**
+     * Test SUR properties of the query
+     */
+    public void runTest() 
+        throws SQLException
+    {
+        println(query);
+        DatabaseMetaData dbMeta = con.getMetaData();
+                
+        if (dbMeta.ownDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE)) {
+            checkRowDeleted = true;
+        }
+        
+        Statement s = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
+                                          ResultSet.CONCUR_UPDATABLE);
+        
+        s.setCursorName(cursorName);
+        ResultSet rs = s.executeQuery(query);
+
+        checkRowUpdated = dbMeta.ownUpdatesAreVisible(rs.getType());        
+        checkRowDeleted = dbMeta.ownDeletesAreVisible(rs.getType());
+        
+        // Create map with rows
+        Map rows = createRowMap(rs);
+        
+        // Set of rows which are updated (contains Integer with position in RS)
+        final Set updatedRows = new HashSet();
+        
+        // Set of rows which are deleted (contains Integer with position in RS)
+        final Set deletedRows = new HashSet();
+                
+        // Test navigation
+        testNavigation(rs, rows, updatedRows, deletedRows);
+        
+        // Only test updatability if the ResultSet is updatable:
+        // (Note: this enables the test do run successfully even if
+        // scrollable updatable resultsets are not implemented. 
+        // If SUR is not implemented, a well behaved JDBC driver will 
+        // downgrade the concurrency mode to READ_ONLY).
+        // SUR may be implemented incrementally, i.e first in embedded mode
+        // then in the network driver.)
+        if (rs.getConcurrency()==ResultSet.CONCUR_UPDATABLE) {
+        
+            // update a random sample of 2 records
+            updateRandomSampleOfNRecords(rs, rows, updatedRows, 2); 
+            testNavigation(rs, rows, updatedRows, deletedRows); 
+            
+            // update a random sample of 5 records
+            updateRandomSampleOfNRecords(rs, rows, updatedRows, 5); 
+            testNavigation(rs, rows, updatedRows, deletedRows); 
+            
+            // update a random sample of 10 records
+            updateRandomSampleOfNRecords(rs, rows, updatedRows, 10); 
+            testNavigation(rs, rows, updatedRows, deletedRows); 
+            
+            // delete a random sample of 2 records
+            deleteRandomSampleOfNRecords(rs, rows, deletedRows, 2);
+            testNavigation(rs, rows, updatedRows, deletedRows); 
+            
+            // delete a random sample of 5 records
+            deleteRandomSampleOfNRecords(rs, rows, deletedRows, 5);
+            testNavigation(rs, rows, updatedRows, deletedRows); 
+            
+            // delete a random sample of 10 records
+            deleteRandomSampleOfNRecords(rs, rows, deletedRows, 10);
+            testNavigation(rs, rows, updatedRows, deletedRows); 
+        } else {
+            println("Skipped testing updatability");
+        }
+        
+        rs.close();
+    }
+    
+    /**
+     * Creates a Map of the values in the ResultSet. 
+     * The key object in the map, is the postion in the 
+     * ResultSet (Integer 1..n), while the value is a
+     * concatenation of the strings for all columns in the row.
+     */
+    private Map createRowMap(final ResultSet rs) 
+        throws SQLException
+    {
+        final Map rows = new HashMap();        
+        rs.beforeFirst();
+        assertTrue("Unexpected return from isBeforeFirst()",
+                   rs.isBeforeFirst());
+        
+        int i = 0;
+        int sum = 0;
+        int expectedSum = 0;
+        boolean checkSum = true;
+        while (rs.next()) {
+            expectedSum += i;
+            i++;
+            String row = getRowString(rs);
+            println(row);
+            rows.put(new Integer(i), row);
+            sum += rs.getInt(1);
+            if (rs.getInt(1) < 0) {
+                checkSum = false;
+            }
+        }
+        if (i<SURDataModelSetup.recordCount) {
+            checkSum = false;
+        }
+        
+        assertTrue("Unexpected return from isAfterLast()", rs.isAfterLast());
+        
+        if (checkSum) {
+            assertEquals("Sum for column 1 is not correct", expectedSum, sum);
+        }
+        
+        return rows;
+    }
+
+    /**
+     * Create a random sample of rows
+     * @param rows Map to create sample from
+     * @param k number of rows in the sample
+     * @return a list containing k elements of rows
+     **/
+    private List createRandomSample(final Map rows, int k) {
+        Random r = new Random();
+        ArrayList sampledKeys = new ArrayList();
+        int n = 0;        
+        for (Iterator i = rows.keySet().iterator(); i.hasNext();) {
+            Object key = i.next();
+            n++;            
+            if (n<=k) {
+                sampledKeys.add(key);
+            } else {
+                // sampledKeys now has a size of k
+                double d = r.nextDouble();
+                // p = probability of going into the sample
+                double p = (double) k / (double) n; 
+                if (d<p) {
+                    // Replace a random value from the sample with the new value
+                    int keyToReplace = Math.abs(r.nextInt())%k;                    
+                    sampledKeys.set(keyToReplace, key);
+                }
+            }
+        }
+        return sampledKeys;
+    }
+    
+    /**
+     * Delete a random sample of n records in the resultset
+     * @param rs result set to be updated
+     * @param rows map of rows, will also be updated
+     * @param deletedRows set of rows being deleted (position in RS)
+     * @param k number of records to be deleted
+     */
+    private void deleteRandomSampleOfNRecords(final ResultSet rs, 
+                                              final Map rows,
+                                              final Set deletedRows,
+                                              final int k) 
+        throws SQLException
+    {
+        List sampledKeys = createRandomSample(rows, k);
+        println("Sampled keys:" + sampledKeys);
+        ResultSetMetaData meta = rs.getMetaData();
+        for (Iterator i = sampledKeys.iterator(); i.hasNext();) {
+            Integer key = (Integer) i.next();
+            rs.absolute(key.intValue());            
+            if (rs.rowDeleted()) continue; // skip deleting row if already deleted
+            if (positioned) {
+                con.createStatement().executeUpdate
+                        ("DELETE FROM T1 WHERE CURRENT OF \"" + cursorName + 
+                         "\"");
+                
+                rs.relative(0); // If this call is not here, the old values are
+                                // returned in rs.getXXX calls
+            } else {
+                rs.deleteRow();
+            }
+            println("Deleted row " + key);
+            // Update the rows table
+            rows.put(key, getRowString(rs));
+            
+            // Update the updatedRows set
+            deletedRows.add(key);
+        }
+    }
+    
+    /**
+     * Update a random sample of n records in the resultset
+     * @param rs result set to be updated
+     * @param rows map of rows, will also be updated
+     * @param updatedRows set of being updated (position in RS)
+     * @param k number of records to be updated
+     */
+    private void updateRandomSampleOfNRecords(final ResultSet rs, 
+                                              final Map rows,
+                                              final Set updatedRows,
+                                              final int k) 
+        throws SQLException
+    {
+        List sampledKeys = createRandomSample(rows, k);
+        println("Sampled keys:" + sampledKeys);
+        ResultSetMetaData meta = rs.getMetaData();
+        for (Iterator i = sampledKeys.iterator(); i.hasNext();) {
+            Integer key = (Integer) i.next();
+            rs.absolute(key.intValue());            
+            
+            if (positioned) {
+                updatePositioned(rs, meta);
+                rs.relative(0); // If this call is not here, the old values are
+                                // returned in rs.getXXX calls
+            } else {
+                updateRow(rs, meta);
+            }
+            // Update the rows table
+            rows.put(key, getRowString(rs));
+            
+            // Update the updatedRows set
+            updatedRows.add(key);
+        }
+    }
+
+    /**
+     * Updates the current row in the ResultSet using updateRow()
+     * @param rs ResultSet to be updated
+     * @param meta meta for the ResultSet
+     **/
+    private void updateRow(final ResultSet rs, final ResultSetMetaData meta) 
+        throws SQLException
+    {
+        for (int column = 1; column<=meta.getColumnCount(); column++) {
+            if (meta.getColumnType(column)==Types.INTEGER) {
+                // Set to negative value
+                rs.updateInt(column, -rs.getInt(column));
+            } else {
+                rs.updateString(column, "UPDATED_" + rs.getString(column));
+            }
+        }
+        rs.updateRow();
+    }
+    
+    /**
+     * Updates the current row in the ResultSet using updateRow()
+     * @param rs ResultSet to be updated
+     * @param meta meta for the ResultSet
+     **/
+    private void updatePositioned(final ResultSet rs, 
+                                  final ResultSetMetaData meta) 
+        throws SQLException                          
+    {
+        StringBuffer sb = new StringBuffer();
+        sb.append("UPDATE T1 SET ");
+        for (int column = 1; column<=meta.getColumnCount(); column++) {
+            sb.append(meta.getColumnName(column));
+            sb.append("=?");
+            if (column<meta.getColumnCount()) {
+                sb.append(",");
+            }
+        }
+        sb.append(" WHERE CURRENT OF \"");
+        sb.append(cursorName);
+        sb.append("\"");
+        println(sb.toString());
+        PreparedStatement ps = con.prepareStatement(sb.toString());
+        
+        for (int column = 1; column<=meta.getColumnCount(); column++) {
+           if (meta.getColumnType(column)==Types.INTEGER) {
+                // Set to negative value
+                ps.setInt(column, -rs.getInt(column));
+            } else {
+                ps.setString(column, "UPDATED_" + rs.getString(column));
+            }
+        }
+        assertEquals("Expected one row to be updated", 1, ps.executeUpdate());        
+    }
+    
+    
+    /**
+     * Tests navigation in ResultSet. This test requires that the ResultSet
+     * is not empty, and positioned before the first row. Also the 
+     * ResultSet needs to contain column a or column id as the first column from
+     * the SURDataModel (for checksum test)
+     * @return a Map with all rows in the resultset (concatnated as a string)
+     */
+    private void testNavigation(final ResultSet rs, final Map rows, 
+                                final Set updatedRows, final Set deletedRows) 
+        throws SQLException
+    {        
+        rs.afterLast();
+        {
+            int i = rows.size();
+            while (rs.previous()) {
+                String rowString = getRowString(rs);
+                assertEquals("Navigating with rs.previous(). The row is " +
+                             "different compared to the value when navigating " +
+                             "forward.", rows.get(new Integer(i)), rowString);
+                
+                
+                if (checkRowUpdated && updatedRows.contains(new Integer(i))) {
+                    assertTrue("Expected rs.rowUpdated() to return true on " + 
+                               "updated row " + rowString, rs.rowUpdated());
+                } 
+                if (checkRowDeleted && deletedRows.contains(new Integer(i))) {
+                    assertTrue("Expected rs.rowDeleted() to return true on " + 
+                               "deleted row " + rowString, rs.rowDeleted());
+                } 
+                i--;
+            }
+        }
+        // Test absolute
+        for (int i = 1; i <= rows.size(); i++) {
+            assertTrue("Unexpected return from absolute()", rs.absolute(i));
+            String rowString = getRowString(rs);
+            assertEquals("Navigating with rs.absolute(). The row is " +
+                         "different compared to the value" +
+                         " when navigating forward.", 
+                         rows.get(new Integer(i)),
+                         rowString);
+            if (checkRowUpdated && updatedRows.contains(new Integer(i))) {
+                assertTrue("Expected rs.rowUpdated() to return true on " +
+                           "updated row " + rowString, rs.rowUpdated());
+            }
+            if (checkRowDeleted && deletedRows.contains(new Integer(i))) {
+                assertTrue("Expected rs.rowDeleted() to return true on " +
+                           "deleted row " + rowString, rs.rowDeleted());
+            }
+        }
+        assertFalse("Unexpected return from absolute()", rs.absolute(0));
+        assertTrue("Unexpected return from isBeforeFirst()", 
+                   rs.isBeforeFirst());
+        assertFalse("Unexpected return from absolute()", 
+                    rs.absolute(rows.size() + 1));
+        assertTrue("Unexpected return from isAfterLast()", rs.isAfterLast());
+        assertTrue("Unexpected return from absolute()", rs.absolute(-1));
+        assertTrue("Unexpected return from isLast()", rs.isLast());
+        assertTrue("Unexpected return from absolute()", rs.absolute(1));
+        assertTrue("Unexpected return from isFirst()", rs.isFirst());
+        
+        // Test relative
+        {
+            rs.beforeFirst();
+            assertTrue("Unexptected return from isBeforeFirst()", 
+                       rs.isBeforeFirst());
+            
+            int relativePos = rows.size();
+            assertTrue("Unexpected return from relative()", 
+                       rs.relative(relativePos)); 
+            
+            // Should now be on the last row
+            assertTrue("Unexptected return from isLast()", rs.isLast());
+            assertEquals("Navigating with rs.relative(+). " +
+                         "A tuple was different compared to the value" +
+                         " when navigating forward.", 
+                         rows.get(new Integer(relativePos)),
+                         getRowString(rs));
+            
+            assertTrue("Unexpected return from relative()", 
+                       rs.relative((-relativePos + 1))); 
+            
+            // Should now be on the first row
+            assertTrue("Unexptected return from isFirst()", rs.isFirst());
+            
+            assertEquals("Navigating with rs.relative(-). " + 
+                         "A tuple was different compared to the value" +
+                         " when navigating forward.", 
+                         rows.get(new Integer(1)),
+                         getRowString(rs));
+            
+        }
+        // Test navigation in the end of the ResultSet
+        rs.afterLast();
+        assertTrue("Unexpected return from isAfterLast()", rs.isAfterLast());
+        assertTrue("Unexpected return from previous()", rs.previous());
+        assertTrue("Unexpected return from isLast()", rs.isLast());
+        assertFalse("Unexpected return from next()", rs.next());
+        assertTrue("Unexpected return from isAfterLast()", rs.isAfterLast());
+        rs.last();
+        assertTrue("Unexpected return from isLast()", rs.isLast());
+        assertFalse("Unexpected return from next()", rs.next());
+        assertTrue("Unexpected return from isAfterLast()", rs.isAfterLast());
+
+
+        // Test navigation in the beginning of the ResultSet
+        rs.beforeFirst();
+        assertTrue("Unexpected return from isBeforeFirst()", 
+                   rs.isBeforeFirst());
+        assertTrue("Unexpected return from next()", rs.next());
+        assertTrue("Unexpected return from isFirst", rs.isFirst());
+        assertFalse("Unexpected return from previous()", rs.previous());
+        assertTrue("Unexpected return from isBeforeFirst()", 
+                   rs.isBeforeFirst());
+        
+        rs.first();
+        assertTrue("Unexpected return from isFirst", rs.isFirst());
+        assertFalse("Unexpected return from previous()", rs.previous());
+        assertTrue("Unexpected return from isBeforeFirst()", 
+                   rs.isBeforeFirst());
+    }
+
+    /**
+     * Get a concatenation of the values of the 
+     * current Row in the ResultSet
+     */
+    private String getRowString(final ResultSet rs) 
+        throws SQLException
+    {
+        int numberOfColumns = rs.getMetaData().getColumnCount();
+        StringBuffer sb = new StringBuffer();
+        if (rs.rowDeleted()) return "";
+        for (int i = 1; i <= numberOfColumns; i++) {
+            sb.append(rs.getString(i));
+            if (i < numberOfColumns) { 
+                sb.append(','); 
+            }
+        }
+        return sb.toString();
+    }
+    
+    private final String query;
+    private final String cursorName;
+    private final boolean positioned;
+    private boolean checkRowUpdated;
+    private boolean checkRowDeleted;
+    
+    private final static String[] selectConditions = new String[] {
+        "WHERE c like 'T%'",
+        " ",        
+        "WHERE b > 5",
+        "WHERE id >= a",
+        "WHERE id > 1 and id < 900",
+        "WHERE id = 1",
+        "WHERE id in (1,3,4,600,900,955,966,977,978)",
+        "WHERE a in (1,3,4,600,9200,955,966,977,978)",
+        "WHERE a>2 and a<9000"
+    };
+    
+    private final static String[] projectConditions = new String[] {
+        "id,c,a,b",
+        "id,c",
+        "a,b",
+        "*",
+        "id,a,b,c",        
+        "id,a",           
+        "a,b,c",        
+        "a,c"
+    };
+    
+    private static TestSuite createTestCases(final String modelName) {
+        TestSuite suite = new TestSuite();
+        for (int doPos = 0; doPos<2; doPos++) {
+            boolean positioned = doPos>0; // true if to use positioned updates
+
+            for (int i = 0; i < selectConditions.length; i++) {
+                for (int j = 0; j < projectConditions.length; j++) {
+                    final String cursorName = "cursor_" + i + "_" + j;
+                    
+                    final String stmtString = "SELECT " + projectConditions[j] +
+                            " FROM T1 " + selectConditions[i];
+                    suite.addTest(new SURQueryMixTest(modelName, stmtString, cursorName, 
+                                              positioned));
+                }
+            }
+        }
+        return suite;
+    }
+    
+    /**
+     * The suite contains all testcases in this class running on different data models
+     */
+    public static Test suite() 
+    {   
+        TestSuite mainSuite = new TestSuite();
+        
+        // Iterate over all data models and decorate the tests:
+        for (Iterator i = SURDataModelSetup.SURDataModel.values().iterator();
+             i.hasNext();) {
+            
+            SURDataModelSetup.SURDataModel model =
+                (SURDataModelSetup.SURDataModel) i.next();
+            
+            TestSuite suite = createTestCases(model.toString());
+            TestSetup decorator = new SURDataModelSetup(suite, model);
+            mainSuite.addTest(decorator);
+        }
+        return mainSuite;
+    }
+    
+  
+}

Propchange: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURQueryMixTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURQueryMixTest_app.properties
URL: http://svn.apache.org/viewcvs/db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURQueryMixTest_app.properties?rev=378045&view=auto
==============================================================================
--- db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURQueryMixTest_app.properties (added)
+++ db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURQueryMixTest_app.properties Wed Feb 15 10:18:47 2006
@@ -0,0 +1,3 @@
+runwithibm13=false
+runwithjdk13=false
+runwithjdk12=false

Propchange: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURQueryMixTest_app.properties
------------------------------------------------------------------------------
    svn:eol-style = native

Added: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURTest.java
URL: http://svn.apache.org/viewcvs/db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURTest.java?rev=378045&view=auto
==============================================================================
--- db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURTest.java (added)
+++ db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURTest.java Wed Feb 15 10:18:47 2006
@@ -0,0 +1,887 @@
+/*
+ *
+ * Derby - Class SURTest
+ *
+ * Copyright 2006 The Apache Software Foundation or its
+ * licensors, as applicable.
+ *
+ * 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 org.apache.derbyTesting.functionTests.tests.jdbcapi;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.Statement;
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import java.util.Iterator;
+/**
+ * Tests for variants of scrollable updatable resultsets.
+ *
+ * @author Andreas Korneliussen
+ */
+public class SURTest extends SURBaseTest {
+    
+    /** Creates a new instance of SURTest */
+    public SURTest(String name) {
+        super(name);
+    }
+    
+    /**
+     * Test that you get a warning when specifying a query which is not
+     * updatable and concurrency mode CONCUR_UPDATABLE.
+     * In this case, the query contains an "order by"
+     */
+    public void testConcurrencyModeWarning1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1 order by a");
+        
+        SQLWarning warn = rs.getWarnings();
+        assertEquals("Expected resultset to be read only",
+                     ResultSet.CONCUR_READ_ONLY,
+                     rs.getConcurrency());
+        assertNotNull("Expected to get a warning", warn);
+        scrollForward(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test that you get a warning when specifying a query which is not
+     * updatable and concurrency mode CONCUR_UPDATABLE.
+     * In this case, the query contains a join.
+     */
+    public void testConcurrencyModeWarning2()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery
+            ("select * from t1 as table1,t1 as table2 where " +
+             "table1.a=table2.a");
+        
+        SQLWarning warn = rs.getWarnings();
+        assertEquals("Expected resultset to be read only",
+                     ResultSet.CONCUR_READ_ONLY,
+                     rs.getConcurrency());
+        assertNotNull("Expected to get a warning", warn);
+        scrollForward(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test that you get an exception when specifying update clause
+     * "FOR UPDATE"
+     * along with a query which is not updatable.
+     * In this case, the query contains and order by.
+     */
+    public void testForUpdateException1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_UPDATABLE);
+        try {
+            String queryString =
+                "select * from t1 order by a for update";
+            s.setCursorName(getNextCursorName());
+            ResultSet rs = s.executeQuery(queryString);
+            
+            assertTrue("Expected query '" + queryString +
+                       "' to fail", false);
+        } catch (SQLException e) {
+            assertEquals("Unexpected SQLState", 
+                         FOR_UPDATE_NOT_PERMITTED_SQL_STATE,
+                         e.getSQLState());
+        }
+        con.rollback();
+    }
+    
+    /**
+     * Test that you get an exception when specifying update clause
+     * "FOR UPDATE" along with a query which is not updatable.
+     * In this case, the query contains a join
+     */
+    public void testForUpdateException2()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_UPDATABLE);
+        try {
+            String queryString =
+                "select * from t1 as table1,t1 as table2" +
+                " where table1.a=table2.a for update";
+            s.setCursorName(getNextCursorName());
+            ResultSet rs = s.executeQuery(queryString);
+            
+            assertTrue("Expected query '" + queryString + "' to fail",
+                       false);
+        } catch (SQLException e) {
+            assertEquals("Unexpected SQLState", 
+                         FOR_UPDATE_NOT_PERMITTED_SQL_STATE,
+                         e.getSQLState());
+        }
+        con.rollback();
+    }
+    
+    /**
+     * Test that you can scroll forward and read all records in the
+     * ResultSet
+     */
+    public void testForwardOnlyReadOnly1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_READ_ONLY);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        scrollForward(rs);
+        rs.close();
+    }
+    
+    
+    /**
+     * Test that you get an exception if you try to update a ResultSet
+     * with concurrency mode CONCUR_READ_ONLY.
+     */
+    public void testFailOnUpdateOfReadOnlyResultSet1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_READ_ONLY);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        rs.next();
+        assertFailOnUpdate(rs);
+    }
+    
+    /**
+     * Test that you get an exception when attempting to update a
+     * ResultSet which has been downgraded to a read only ResultSet.
+     */
+    public void testFailOnUpdateOfReadOnlyResultSet2()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1 order by id");
+        
+        rs.next();
+        assertFailOnUpdate(rs);
+    }
+    
+    /**
+     * Test that you get an exception when attempting to update a
+     * ResultSet which has been downgraded to a read only ResultSet.
+     */
+    public void testFailOnUpdateOfReadOnlyResultSet3()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs =
+            s.executeQuery("select * from t1 for read only");
+        
+        rs.next();
+        assertFailOnUpdate(rs);
+    }
+    
+    /**
+     * Test that you get an exception when attempting to update a
+     * ResultSet which has been downgraded to a read only ResultSet.
+     */
+    public void testFailOnUpdateOfReadOnlyResultSet4()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery
+            ("select * from t1 where a=1 for read only");
+        
+        rs.next();
+        verifyTuple(rs);
+        assertFailOnUpdate(rs);
+    }
+    
+    
+    /**
+     * Test that you get an exception if you try to update a ResultSet
+     * with concurrency mode CONCUR_READ_ONLY.
+     */
+    public void testFailOnUpdateOfReadOnlyResultSet5()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.
+                                          TYPE_SCROLL_INSENSITIVE,
+                                          ResultSet.CONCUR_READ_ONLY);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery
+            ("select * from t1 where a=1 for read only");
+        
+        rs.next();
+        verifyTuple(rs);
+        assertFailOnUpdate(rs);
+    }
+    
+    /**
+     * Test that you can scroll forward and update indexed records in
+     * the ResultSet (not using FOR UPDATE)
+     */
+    public void testIndexedUpdateCursor1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1 where a=1");
+        
+        assertTrue("Expected to get a tuple on rs.next()", rs.next());
+        verifyTuple(rs);
+        updateTuple(rs);
+        
+    }
+    
+    /**
+     *  Test that you can scroll forward and update indexed records
+     *  in the ResultSet (using FOR UPDATE).
+     */
+    public void testIndexedUpdateCursor2()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs =
+            s.executeQuery("select * from t1 where a=1 for update");
+        
+        assertTrue("Expected to get a tuple on rs.next()", rs.next());
+        verifyTuple(rs);
+        updateTuple(rs);
+    }
+    
+    /**
+     *  Test that you can scroll forward and update indexed records
+     *  in the scrollable ResultSet (not using FOR UPDATE).
+     */
+    public void
+        testIndexedScrollInsensitiveUpdateCursorWithoutForUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_SCROLL_INSENSITIVE,
+             ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs =
+            s.executeQuery("select * from t1 where a=1 or a=2");
+        
+        rs.next();
+        rs.next();
+        rs.previous();
+        verifyTuple(rs);
+        updateTuple(rs);
+    }
+    
+    /**
+     *  Test that you can scroll forward and update indexed records
+     *  in the scrollable ResultSet (using FOR UPDATE).
+     */
+    public void
+        testIndexedScrollInsensitiveUpdateCursorWithForUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_SCROLL_INSENSITIVE,
+             ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery
+            ("select * from t1 where a=1 or a=2 for update");
+        
+        rs.next();
+        rs.next();
+        rs.previous();
+        verifyTuple(rs);
+        updateTuple(rs);
+        rs.close();
+        s.close();
+    }
+   
+    /**
+     * Test update of a keyed record using scrollable updatable
+     * resultset.
+     */
+    public void testPrimaryKeyUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_SCROLL_INSENSITIVE,
+             ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        rs.last();
+        rs.next();
+        while(rs.previous()) {
+            // Update the key of every second row.
+            int key = rs.getInt(1);
+            if (key%2==0) {
+                int newKey = -key;
+                rs.updateInt(1, newKey);
+                rs.updateRow();
+            }
+        }
+        PreparedStatement ps = con.prepareStatement
+            ("select * from t1 where id=?");
+        for (int i=0; i<recordCount; i++) {
+            int key = (i%2==0) ? -i : i;
+            ps.setInt(1, key);
+            ResultSet rs2 = ps.executeQuery();
+            assertTrue("Expected query to have 1 row", rs2.next());
+            println("T1: Read Tuple:(" + rs2.getInt(1) + "," +
+                    rs2.getInt(2) + "," +
+                    rs2.getInt(3) + ")");
+            assertEquals("Unexpected value of id", key, rs2.getInt(1));
+            assertTrue("Did not expect more than 1 row, " +
+                       "however rs2.next returned another row",
+                       !rs2.next());
+        }
+    }
+        
+    /**
+     * Test update of a keyed record using other statement
+     * object.
+     */
+    public void testOtherPrimaryKeyUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_SCROLL_INSENSITIVE,
+             ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        rs.last();
+        int primaryKey = rs.getInt(1);
+        PreparedStatement ps = con.prepareStatement
+            ("update t1 set id = ? where id= ?");
+        ps.setInt(1, -primaryKey);
+        ps.setInt(2, primaryKey);
+        assertEquals("Expected one row to be updated", 1,
+                     ps.executeUpdate());
+        
+        rs.updateInt(2, -555);
+        rs.updateInt(3, -777);
+        rs.updateRow();
+        
+        PreparedStatement ps2 = con.prepareStatement
+            ("select * from t1 where id=?");
+        ps2.setInt(1, -primaryKey);
+        ResultSet rs2 = ps2.executeQuery();
+        assertTrue("Expected query to have 1 row", rs2.next());
+        println("T1: Read Tuple:(" + rs2.getInt(1) + "," +
+                rs2.getInt(2) + "," +
+                rs2.getInt(3) + ")");
+        assertEquals("Expected a=-555", -555, rs2.getInt(2));
+        assertEquals("Expected b=-777", -777, rs2.getInt(3));
+        assertTrue("Did not expect more than 1 row, however " +
+                   "rs2.next() returned another row", !rs2.next());
+    }
+    
+    /**
+     * Test update of a keyed record using other both the
+     * scrollable updatable resultset and using another statement
+     * object.
+     */
+    public void testOtherAndOwnPrimaryKeyUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_SCROLL_INSENSITIVE,
+             ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        rs.last();
+        int primaryKey = rs.getInt(1);
+        PreparedStatement ps = con.prepareStatement
+            ("update t1 set id = ? where id= ?");
+        ps.setInt(1, -primaryKey);
+        ps.setInt(2, primaryKey);
+        assertEquals("Expected one row to be updated", 1,
+                     ps.executeUpdate());
+        rs.updateInt(1, primaryKey*10);
+        rs.updateInt(2, -555);
+        rs.updateInt(3, -777);
+        rs.updateRow();
+        
+        PreparedStatement ps2 =
+            con.prepareStatement("select * from t1 where id=?");
+        ps2.setInt(1, primaryKey*10);
+        ResultSet rs2 = ps2.executeQuery();
+        assertTrue("Expected query to have 1 row", rs2.next());
+        println("T1: Read Tuple:(" + rs2.getInt(1) + "," +
+                rs2.getInt(2) + "," +
+                rs2.getInt(3) + ")");
+        assertEquals("Expected a=-555", -555, rs2.getInt(2));
+        assertEquals("Expected b=-777", -777, rs2.getInt(3));
+        assertTrue("Did not expect more than 1 row, however " +
+                   "rs2.next() returned another row", !rs2.next());
+    }
+    
+    /**
+     * Update multiple keyed records using scrollable updatable resultset
+     */
+    public void testMultipleKeyUpdates()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_SCROLL_INSENSITIVE,
+             ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        rs.last();
+        int primaryKey = rs.getInt(1);
+        PreparedStatement ps = con.prepareStatement
+            ("update t1 set id = ? where id= ?");
+        ps.setInt(1, -primaryKey);
+        ps.setInt(2, primaryKey);
+        assertEquals("Expected one row to be updated", 1,
+                     ps.executeUpdate());
+        rs.updateInt(1, primaryKey*10);
+        rs.updateInt(2, -555);
+        rs.updateInt(3, -777);
+        rs.updateRow();
+        rs.first();
+        rs.last();
+        for (int i=0; i<10; i++) {
+            rs.first();
+            rs.last();
+            rs.next();
+            rs.previous();
+            rs.updateInt(1, primaryKey*10 +i);
+            rs.updateInt(2, (-555 -i));
+            rs.updateInt(3, (-777 -i));
+            rs.updateRow();
+        }
+    }
+    
+    /**
+     * Test update indexed records using scrollable updatable resultset 
+     */
+    public void testSecondaryIndexKeyUpdate1()
+        throws SQLException 
+    {
+        
+        Statement s = con.createStatement
+            (ResultSet.TYPE_SCROLL_INSENSITIVE,
+             ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        rs.last();
+        rs.next();
+        int newKey = 0;
+        while(rs.previous()) {
+            // Update the secondary key of all rows
+            rs.updateInt(2, newKey--);
+            rs.updateRow();
+        }
+        PreparedStatement ps = con.prepareStatement
+            ("select * from t1 where a=?");
+        for (int i=0; i<recordCount; i++) {
+            int key = -i;
+            ps.setInt(1, key);
+            ResultSet rs2 = ps.executeQuery();
+            assertTrue("Expected query to have 1 row", rs2.next());
+            println("T1: Read Tuple:(" + rs2.getInt(1) + "," +
+                    rs2.getInt(2) + "," +
+                    rs2.getInt(3) + ")");
+            assertEquals("Unexpected value of id", key, rs2.getInt(2));
+            assertTrue("Did not expect more than 1 row, " +
+                       "however rs2.next returned another row",
+                       !rs2.next());
+        }
+    }
+    
+    /**
+     * Test update indexed records using other statement object
+     * and using resultset.
+     */
+    public void testOtherSecondaryKeyUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_SCROLL_INSENSITIVE,
+             ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        rs.last();
+        int indexedKey = rs.getInt(2);
+        PreparedStatement ps =
+            con.prepareStatement("update t1 set a = ? where a= ?");
+        ps.setInt(1, -indexedKey);
+        ps.setInt(2, indexedKey);
+        assertEquals("Expected one row to be updated", 1,
+                     ps.executeUpdate());
+        
+        rs.updateInt(1, -555);
+        rs.updateInt(3, -777);
+        rs.updateRow();
+        
+        PreparedStatement ps2 =
+            con.prepareStatement("select * from t1 where a=?");
+        ps2.setInt(1, -indexedKey);
+        ResultSet rs2 = ps2.executeQuery();
+        assertTrue("Expected query to have 1 row", rs2.next());
+        println("T1: Read Tuple:(" + rs2.getInt(1) + "," +
+                rs2.getInt(2) + "," +
+                rs2.getInt(3) + ")");
+        assertEquals("Expected id=-555", -555, rs2.getInt(1));
+        assertEquals("Expected b=-777", -777, rs2.getInt(3));
+        assertTrue("Did not expect more than 1 row, however " +
+                   "rs2.next() returned another row", !rs2.next());
+    }
+    
+    /**
+     * Test scrolling in a read only resultset
+     */
+    public void testScrollInsensitiveReadOnly1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_SCROLL_INSENSITIVE,
+             ResultSet.CONCUR_READ_ONLY);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        scrollForward(rs);
+        scrollBackward(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test updating a forward only resultset (with FOR UPDATE)
+     */
+    public void testForwardOnlyConcurUpdatableWithForUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1 for update");
+        
+        scrollForwardAndUpdate(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test updating a forward only resultset (without FOR UPDATE)
+     */
+    public void testForwardOnlyConcurUpdatableWithoutForUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        scrollForwardAndUpdate(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test updating a forward only resultset (without FOR UPDATE)
+     * and using positioned update
+     */
+    public void testPositionedUpdateWithoutForUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName("MYCURSOR");
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        scrollForwardAndUpdatePositioned(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test updating a forward only resultset (with FOR UPDATE)
+     * and using positioned update
+     */
+    public void testPositionedUpdateWithForUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement();
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1 for update");
+        
+        scrollForwardAndUpdatePositioned(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test positioned update of a scrollable resultset (with FOR UPDATE) 
+     */
+    public void testScrollablePositionedUpdateWithForUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement
+            (ResultSet.TYPE_SCROLL_INSENSITIVE,
+             ResultSet.CONCUR_READ_ONLY);
+        s.setCursorName("MYCURSOR");
+        ResultSet rs = s.executeQuery("select * from t1 for update");
+        
+        rs.next();
+        int pKey = rs.getInt(1);
+        rs.previous();
+        rs.next();
+        assertEquals("Expecting to be on the same row after previous() " + 
+                     "+ next() ", pKey, rs.getInt(1));
+        rs.next();
+        rs.previous();
+        assertEquals("Expecting to be on the same row after next() + " + 
+                     "previous()", pKey, rs.getInt(1));
+        final int previousA = rs.getInt(2);
+        final int previousB = rs.getInt(3);
+        println(rs.getCursorName());
+        PreparedStatement ps = con.prepareStatement
+            ("update T1 set a=?,b=? where current of " + rs.getCursorName());
+        ps.setInt(1, 666);
+        ps.setInt(2, 777);
+        ps.executeUpdate();
+        rs.next();
+        rs.previous();
+        assertEquals("Expected to be on the same row after next() + previous()",
+                     pKey, rs.getInt(1));
+        assertEquals("Expected row to be updated by own change, " + 
+                     " however did not get updated value for column a", 
+                     666, rs.getInt(2));
+        assertEquals("Expected row to be updated by own change, however did " +
+                     "not get updated value for column b", 777, rs.getInt(3));
+        rs.close();
+        s.setCursorName(getNextCursorName());
+        rs = s.executeQuery("select * from t1 order by b");
+        
+        while (rs.next()) {
+            if (rs.getInt(1)==pKey) {
+                assertEquals("Expected row with primary key = " + pKey + 
+                             " to be updated", 666, rs.getInt(2));
+                assertEquals("Expected row with primary key = " + pKey + 
+                             " to be updated", 777, rs.getInt(3));
+            } else {
+                println("Got tuple (" + rs.getInt(1) + "," + rs.getInt(2) + 
+                        "," + rs.getInt(3) + "," + rs.getString(4)+ ")");
+            }
+        }
+        
+    }
+    
+    /**
+     * Test update of a scrollable resultset (with FOR UPDATE)
+     * Only scrolling forward
+     */
+    public void testScrollInsensitiveConcurUpdatableWithForUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1 for update");
+        scrollForwardAndUpdate(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test update of a scrollable resultset (with FOR UPDATE) 
+     * Scrolling forward and backward.
+     */
+    public void testScrollInsensitiveConcurUpdatableWithForUpdate2()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 
+                                          ResultSet.CONCUR_UPDATABLE);
+        assertEquals("Invalid resultset concurrency on statement", 
+                     ResultSet.CONCUR_UPDATABLE, s.getResultSetConcurrency());
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1 for update");
+        
+        assertEquals("Invalid resultset concurrency on resultset", 
+                     ResultSet.CONCUR_UPDATABLE, rs.getConcurrency());
+        scrollForward(rs);
+        scrollBackwardAndUpdate(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test update of a scrollable resultset
+     * Scrolling forward and backward. Then open another
+     * resultset and verify the data.
+     */
+    private void testScrollInsensistiveConurUpdatable3(ResultSet rs) 
+        throws SQLException 
+    {
+        while (rs.next()) {
+        }
+        while (rs.previous()) {
+            int a = rs.getInt(1);
+            int b = rs.getInt(2);
+            int id = b - 17 - a;
+            int newA = 1000;
+            int newB = id + newA + 17;
+            rs.updateInt(1, newA); // Set a to 1000
+            rs.updateInt(2, newB); // Set b to checksum value
+            rs.updateRow();
+            
+            assertEquals("Expected a to be 1000", 1000, rs.getInt(1));
+        }
+        int count = 0;
+        while (rs.next()) {
+            int a = rs.getInt(1);
+            count++;
+            assertEquals("Incorrect row updated for row " + count, 1000, a);
+        }
+        assertEquals("Expected count to be the same as number of records", 
+                     recordCount, count);
+        while (rs.previous()) {
+            int a = rs.getInt(1);
+            count--;
+            assertEquals("Incorrect row updated for row " + count, 1000, a);
+        }
+        rs.close();
+        Statement s = con.createStatement(ResultSet.TYPE_FORWARD_ONLY, 
+                                          ResultSet.CONCUR_READ_ONLY);
+        s.setCursorName(getNextCursorName());
+        rs = s.executeQuery("select * from t1");
+        
+        while (rs.next()) {
+            int id = rs.getInt(1);
+            int a = rs.getInt(2);
+            int b = rs.getInt(3);
+            println("Updated tuple:" + id + "," + a + "," + b);
+        }
+    }
+    
+    /**
+     * Test update of a scrollable resultset (with FOR UPDATE)
+     * Scrolling forward and backward. Then open another
+     * resultset and verify the data.
+     */
+    public void testScrollInsensitiveConcurUpdatableWithForUpdate3()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select a,b from t1 for update");
+        
+        testScrollInsensistiveConurUpdatable3(rs);
+    }
+    
+    /**
+     * Test update of a scrollable resultset (without FOR UPDATE) 
+     * Scrolling forward only
+     */
+    public void testScrollInsensitiveConcurUpdatableWithoutForUpdate1()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        scrollForwardAndUpdate(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test update of a scrollable resultset (without FOR UPDATE) 
+     * Scrolling forward and backward.
+     */
+    public void testScrollInsensitiveConcurUpdatableWithoutForUpdate2()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select * from t1");
+        
+        scrollForward(rs);
+        scrollBackwardAndUpdate(rs);
+        rs.close();
+    }
+    
+    /**
+     * Test update of a scrollable resultset (without FOR UPDATE)
+     * Scrolling forward and backward. Then open another
+     * resultset and verify the data.
+     */
+    public void testScrollInsensitiveConcurUpdatableWithoutForUpdate3()
+        throws SQLException 
+    {
+        Statement s = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 
+                                          ResultSet.CONCUR_UPDATABLE);
+        s.setCursorName(getNextCursorName());
+        ResultSet rs = s.executeQuery("select a,b from t1");
+        
+        testScrollInsensistiveConurUpdatable3(rs);
+    }
+    
+    /**
+     * Get a new cursor name. WORKAROUND FOR DERBY-787, since
+     * the cursors have side-effects..!
+     * To reproduce DERBY-787, just return the same cursor name.
+     */
+    private final String getNextCursorName() {
+        return "MYCURSOR" + cursorIndex++;
+    }
+    
+    private static int cursorIndex = 0;
+
+    
+    /**
+     * The suite contains all testcases in this class running on different 
+     * data models
+     */
+    public static Test suite() {
+        
+        TestSuite mainSuite = new TestSuite();
+        
+        // Iterate over all data models and decorate the tests:
+        for (Iterator i = SURDataModelSetup.SURDataModel.values().iterator();
+             i.hasNext();) {
+            
+            SURDataModelSetup.SURDataModel model = 
+                (SURDataModelSetup.SURDataModel) i.next();
+            
+            TestSuite suite = new TestSuite(SURTest.class);
+            TestSetup decorator = new SURDataModelSetup
+                (suite, model);
+            
+            mainSuite.addTest(decorator);    
+        }
+        
+        return mainSuite;
+    }
+}

Propchange: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURTest_app.properties
URL: http://svn.apache.org/viewcvs/db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURTest_app.properties?rev=378045&view=auto
==============================================================================
--- db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURTest_app.properties (added)
+++ db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURTest_app.properties Wed Feb 15 10:18:47 2006
@@ -0,0 +1,3 @@
+runwithibm13=false
+runwithjdk13=false
+runwithjdk12=false

Propchange: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/jdbcapi/SURTest_app.properties
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/util/TestUtil.java
URL: http://svn.apache.org/viewcvs/db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/util/TestUtil.java?rev=378045&r1=378044&r2=378045&view=diff
==============================================================================
--- db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/util/TestUtil.java (original)
+++ db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/util/TestUtil.java Wed Feb 15 10:18:47 2006
@@ -30,7 +30,10 @@
 import java.util.Properties;
 import java.util.StringTokenizer;
 import java.util.NoSuchElementException;
-
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.security.PrivilegedExceptionAction;
+import java.security.PrivilegedActionException;
 import javax.sql.DataSource;
 
 import org.apache.derby.iapi.reference.JDBC30Translation;
@@ -165,7 +168,13 @@
 	{
 		if (framework != UNKNOWN_FRAMEWORK)
 			return framework;
-		String frameworkString = System.getProperty("framework");
+              String frameworkString = (String) AccessController.doPrivileged
+                  (new PrivilegedAction() {
+                          public Object run() {
+                              return System.getProperty("framework");
+                          }
+                      }
+                   );              
 		if (frameworkString == null || 
 		   frameworkString.toUpperCase(Locale.ENGLISH).equals("EMBEDDED"))
 			framework = EMBEDDED_FRAMEWORK;
@@ -199,7 +208,13 @@
     */
     public static String getHostName()
     {
-        String hostName = (System.getProperty("hostName"));
+        String hostName = (String) AccessController.doPrivileged
+            (new PrivilegedAction() {
+                    public Object run() {
+                        return System.getProperty("hostName");
+                    }
+                }
+             );    
         if (hostName == null)
             hostName="localhost";
         return hostName;
@@ -243,7 +258,7 @@
 	*/
 	public static void loadDriver() throws Exception
 	{
-		String driverName = null;
+              final String driverName;
 		framework = getFramework();
 		switch (framework)
 		{
@@ -258,9 +273,23 @@
 			case DERBY_NET_CLIENT_FRAMEWORK:
 				driverName = "org.apache.derby.jdbc.ClientDriver";
 				break;
+                      default: 
+                            driverName=  "org.apache.derby.jdbc.EmbeddedDriver";
+                            break;
 		}
-		Class.forName(driverName).newInstance();
-	}
+                                
+              try {
+                  AccessController.doPrivileged
+                      (new PrivilegedExceptionAction() {
+                              public Object run() throws Exception {
+                                  return Class.forName(driverName).newInstance();
+                              }
+                          }
+                       );
+              } catch (PrivilegedActionException e) {
+                  throw e.getException();
+              }
+        }
 
 
 	/**



Mime
View raw message