Index: src/test/org/apache/commons/dbcp/managed/TestManagedDataSource.java
===================================================================
--- src/test/org/apache/commons/dbcp/managed/TestManagedDataSource.java	(revision 556144)
+++ src/test/org/apache/commons/dbcp/managed/TestManagedDataSource.java	(working copy)
@@ -126,28 +126,6 @@
         connectionB.close();
     }
 
-    public void testCantCloseConnectionTwice() throws Exception {
-        // this test is invalid... the JavaDoc and spec for the close method specifically
-        // state that the close method on an already closed connection is a no-op
-    }
-
-
-    /**
-     * Verify the close method can be called multiple times on a single connection without
-     * an exception being thrown.
-     */
-    public void testCanCloseConnectionTwice() throws Exception {
-        for (int i = 0; i < getMaxActive(); i++) { // loop to show we *can* close again once we've borrowed it from the pool again
-            Connection conn = newConnection();
-            assertTrue(null != conn);
-            assertTrue(!conn.isClosed());
-            conn.close();
-            assertTrue(conn.isClosed());
-            conn.close();
-            assertTrue(conn.isClosed());
-        }
-    }
-
     public void testManagedConnectionEqualsSameDelegate() throws Exception {
         // Get a maximal set of connections from the pool
         Connection[] c = new Connection[getMaxActive()];
Index: src/test/org/apache/commons/dbcp/TestManual.java
===================================================================
--- src/test/org/apache/commons/dbcp/TestManual.java	(revision 556144)
+++ src/test/org/apache/commons/dbcp/TestManual.java	(working copy)
@@ -91,16 +91,20 @@
     public void testReportedBug28912() throws Exception {
         Connection conn1 = getConnection();
         assertNotNull(conn1);
+        assertFalse(conn1.isClosed());
         conn1.close();        
-        
+
         Connection conn2 = getConnection();
         assertNotNull(conn2);
-        
-        try {
-            conn1.close();
-            fail("Expected SQLException");
-        }
-        catch (SQLException e) { }
+
+        assertTrue(conn1.isClosed());
+        assertFalse(conn2.isClosed());
+
+        // should be able to call close multiple times with no effect
+        conn1.close();
+
+        assertTrue(conn1.isClosed());
+        assertFalse(conn2.isClosed());
     }
     
     /** @see http://issues.apache.org/bugzilla/show_bug.cgi?id=12400 */
Index: src/test/org/apache/commons/dbcp/TesterResultSet.java
===================================================================
--- src/test/org/apache/commons/dbcp/TesterResultSet.java	(revision 556144)
+++ src/test/org/apache/commons/dbcp/TesterResultSet.java	(working copy)
@@ -79,7 +79,9 @@
     }
 
     public void close() throws SQLException {
-        checkOpen();
+        if (!_open) {
+            return;
+        }
         ((TesterStatement)_statement)._resultSet = null;
         _open = false;
     }
Index: src/test/org/apache/commons/dbcp/TestConnectionPool.java
===================================================================
--- src/test/org/apache/commons/dbcp/TestConnectionPool.java	(revision 556144)
+++ src/test/org/apache/commons/dbcp/TestConnectionPool.java	(working copy)
@@ -148,41 +148,96 @@
         }
     }
 
-    public void testCantCloseConnectionTwice() throws Exception {
-        for(int i=0;i<getMaxActive();i++) { // loop to show we *can* close again once we've borrowed it from the pool again
+    /**
+     * Verify the close method can be called multiple times on a single connection without
+     * an exception being thrown.
+     */
+    public void testCanCloseConnectionTwice() throws Exception {
+        for (int i = 0; i < getMaxActive(); i++) { // loop to show we *can* close again once we've borrowed it from the pool again
             Connection conn = newConnection();
             assertTrue(null != conn);
             assertTrue(!conn.isClosed());
             conn.close();
             assertTrue(conn.isClosed());
-            try {
-                conn.close();
-                fail("Expected SQLException on second attempt to close (" + conn.getClass().getName() + ")");
-            } catch(SQLException e) {
-                // expected
-            }
+            conn.close();
             assertTrue(conn.isClosed());
         }
     }
 
-    public void testCantCloseStatementTwice() throws Exception {
+    public void testCanCloseStatementTwice() throws Exception {
         Connection conn = newConnection();
         assertTrue(null != conn);
         assertTrue(!conn.isClosed());
         for(int i=0;i<2;i++) { // loop to show we *can* close again once we've borrowed it from the pool again
+            Statement stmt = conn.createStatement();
+            assertNotNull(stmt);
+            assertFalse(isClosed(stmt));
+            stmt.close();
+            assertTrue(isClosed(stmt));
+            stmt.close();
+            assertTrue(isClosed(stmt));
+            stmt.close();
+            assertTrue(isClosed(stmt));
+        }
+        conn.close();
+    }
+
+    public void testCanClosePreparedStatementTwice() throws Exception {
+        Connection conn = newConnection();
+        assertTrue(null != conn);
+        assertTrue(!conn.isClosed());
+        for(int i=0;i<2;i++) { // loop to show we *can* close again once we've borrowed it from the pool again
             PreparedStatement stmt = conn.prepareStatement("select * from dual");
-            assertTrue(null != stmt);
+            assertNotNull(stmt);
+            assertFalse(isClosed(stmt));
             stmt.close();
-            try {
-                stmt.close();
-                fail("Expected SQLException on second attempt to close (" + stmt.getClass().getName() + ")");
-            } catch(SQLException e) {
-                // expected
-            }
+            assertTrue(isClosed(stmt));
+            stmt.close();
+            assertTrue(isClosed(stmt));
+            stmt.close();
+            assertTrue(isClosed(stmt));
         }
         conn.close();
     }
 
+    public void testCanCloseCallableStatementTwice() throws Exception {
+        Connection conn = newConnection();
+        assertTrue(null != conn);
+        assertTrue(!conn.isClosed());
+        for(int i=0;i<2;i++) { // loop to show we *can* close again once we've borrowed it from the pool again
+            PreparedStatement stmt = conn.prepareCall("select * from dual");
+            assertNotNull(stmt);
+            assertFalse(isClosed(stmt));
+            stmt.close();
+            assertTrue(isClosed(stmt));
+            stmt.close();
+            assertTrue(isClosed(stmt));
+            stmt.close();
+            assertTrue(isClosed(stmt));
+        }
+        conn.close();
+    }
+
+    public void testCanCloseResultSetTwice() throws Exception {
+        Connection conn = newConnection();
+        assertTrue(null != conn);
+        assertTrue(!conn.isClosed());
+        for(int i=0;i<2;i++) { // loop to show we *can* close again once we've borrowed it from the pool again
+            PreparedStatement stmt = conn.prepareStatement("select * from dual");
+            assertNotNull(stmt);
+            ResultSet rset = stmt.executeQuery();
+            assertNotNull(rset);
+            assertFalse(isClosed(rset));
+            rset.close();
+            assertTrue(isClosed(rset));
+            rset.close();
+            assertTrue(isClosed(rset));
+            rset.close();
+            assertTrue(isClosed(rset));
+        }
+        conn.close();
+    }
+
     public void testSimple() throws Exception {
         Connection conn = newConnection();
         assertTrue(null != conn);
@@ -530,4 +585,30 @@
 
         assertTrue(conn1.hashCode() != conn2.hashCode());
     }
+
+    protected boolean isClosed(Statement statement) {
+        try {
+            statement.getWarnings();
+            return false;
+        } catch (SQLException e) {
+            // getWarnings throws an exception if the statement is
+            // closed, but could throw an exception for other reasons
+            // in this case it is good enought to assume the statement
+            // is closed
+            return true;
+        }
+    }
+
+    protected boolean isClosed(ResultSet resultSet) {
+        try {
+            resultSet.getWarnings();
+            return false;
+        } catch (SQLException e) {
+            // getWarnings throws an exception if the statement is
+            // closed, but could throw an exception for other reasons
+            // in this case it is good enought to assume the result set
+            // is closed
+            return true;
+        }
+    }
 }
Index: src/test/org/apache/commons/dbcp/TesterStatement.java
===================================================================
--- src/test/org/apache/commons/dbcp/TesterStatement.java	(revision 556144)
+++ src/test/org/apache/commons/dbcp/TesterStatement.java	(working copy)
@@ -79,7 +79,11 @@
     }
 
     public void close() throws SQLException {
-        checkOpen();
+        // calling close twice has no effect
+        if (!_open) {
+            return;
+        }
+
         _open = false;
         if (_resultSet != null) {
             _resultSet.close();
Index: src/java/org/apache/commons/dbcp/PoolablePreparedStatement.java
===================================================================
--- src/java/org/apache/commons/dbcp/PoolablePreparedStatement.java	(revision 556144)
+++ src/java/org/apache/commons/dbcp/PoolablePreparedStatement.java	(working copy)
@@ -72,9 +72,8 @@
      * Return me to my pool.
      */
     public void close() throws SQLException {
-        if(isClosed()) {
-            throw new SQLException("Already closed");
-        } else {
+        // calling close twice should have no effect
+        if (!isClosed()) {
             try {
                 _pool.returnObject(_key,this);
             } catch(SQLException e) {
Index: src/java/org/apache/commons/dbcp/cpdsadapter/ConnectionImpl.java
===================================================================
--- src/java/org/apache/commons/dbcp/cpdsadapter/ConnectionImpl.java	(revision 556144)
+++ src/java/org/apache/commons/dbcp/cpdsadapter/ConnectionImpl.java	(working copy)
@@ -113,9 +113,10 @@
      * @exception SQLException The database connection couldn't be closed.
      */
     public void close() throws SQLException {
-        assertOpen();
-        isClosed = true;
-        pooledConnection.notifyListeners();
+        if (!isClosed) {
+            isClosed = true;
+            pooledConnection.notifyListeners();
+        }
     }
 
     /**
Index: src/java/org/apache/commons/dbcp/PoolingDataSource.java
===================================================================
--- src/java/org/apache/commons/dbcp/PoolingDataSource.java	(revision 556144)
+++ src/java/org/apache/commons/dbcp/PoolingDataSource.java	(working copy)
@@ -177,10 +177,11 @@
         }
     
         public void close() throws SQLException {
-            checkOpen();
-            this.delegate.close();
-            this.delegate = null;
-            super.setDelegate(null);
+            if (delegate != null) {
+                this.delegate.close();
+                this.delegate = null;
+                super.setDelegate(null);
+            }
         }
 
         public boolean isClosed() throws SQLException {
Index: src/java/org/apache/commons/dbcp/PoolingDriver.java
===================================================================
--- src/java/org/apache/commons/dbcp/PoolingDriver.java	(revision 556144)
+++ src/java/org/apache/commons/dbcp/PoolingDriver.java	(working copy)
@@ -263,12 +263,13 @@
                 throw new SQLException("Connection is closed.");
             }
         }
-    
+
         public void close() throws SQLException {
-            checkOpen();
-            this.delegate.close();
-            this.delegate = null;
-            super.setDelegate(null);
+            if (delegate != null) {
+                this.delegate.close();
+                this.delegate = null;
+                super.setDelegate(null);
+            }
         }
 
         public boolean isClosed() throws SQLException {
Index: src/java/org/apache/commons/dbcp/DelegatingConnection.java
===================================================================
--- src/java/org/apache/commons/dbcp/DelegatingConnection.java	(revision 556144)
+++ src/java/org/apache/commons/dbcp/DelegatingConnection.java	(working copy)
@@ -208,10 +208,17 @@
      * Closes the underlying connection, and close
      * any Statements that were not explicitly closed.
      */
-    public void close() throws SQLException
-    {
-        passivate();
-        _conn.close();
+    public void close() throws SQLException {
+        // close can be called multiple times, but PoolableConnection improperly
+        // throws an exception when a connection is closed twice, so before calling
+        // close we aren't alreayd closed
+        if (!isClosed()) {
+            try {
+                _conn.close();
+            } finally {
+                _closed = true;
+            }
+        }
     }
 
     protected void handleException(SQLException e) throws SQLException {