s_log.debug("end testDbNotAvailableException");
    public void testDbNotAvailableException() throws SQLException {        // TODO: Figure out other ways to simulate DB failure        // than just garbage connection info?  Is this possible?        java.sql.PreparedStatement insertStmt = null;        java.sql.Connection badConn = null;        try {            badConn = java.sql.DriverManager.getConnection("total garbage");            fail("Using garbage connection info should have caused error");        } catch (SQLException e) {            // Normally the job of parsing the SQLException and re-throwing            // the right type is handled by code in the pool or buried in DB.            // However, here we're using straight JDBC, so we need to explicitly            // cause the parsing to happen.            SQLException wrapped = SQLExceptionHandler.wrap(e);            if (wrapped instanceof DbNotAvailableException) {                // good            } else {                throw new com.arsdigita.util.UncheckedWrapperException                    (wrapped);                /*                fail("Setting garbage connection info should have caused " +                "DbNotAvailableException, instead caused " + wrapped);*/            }        }        try {            badConn = java.sql.DriverManager.getConnection("jdbc:totalgarbage");            fail("Using garbage connection info should have caused error");        } catch (SQLException e) {            // Normally the job of parsing the SQLException and re-throwing            // the right type is handled by code in the pool or buried in DB.            // However, here we're using straight JDBC, so we need to explicitly            // cause the parsing to happen.            SQLException wrapped = SQLExceptionHandler.wrap(e);            if (wrapped instanceof DbNotAvailableException) {                // good            } else {                fail("Setting garbage connection info should have caused " +                     "DbNotAvailableException, instead caused " + wrapped);            }        }        try {            badConn = java.sql.DriverManager.getConnection("jdbc:oracle:garbage");            fail("Using garbage connection info should have caused error");        } catch (SQLException e) {            // Normally the job of parsing the SQLException and re-throwing            // the right type is handled by code in the pool or buried in DB.            // However, here we're using straight JDBC, so we need to explicitly            // cause the parsing to happen.            SQLException wrapped = SQLExceptionHandler.wrap(e);            if (wrapped instanceof DbNotAvailableException) {                // good            } else {                fail("Setting garbage connection info should have caused " +                     "DbNotAvailableException, instead caused " + wrapped);            }        }        try {            badConn = java.sql.DriverManager.getConnection("jdbc:oracle:oci8:@totalgarbage");            insertStmt =                badConn.prepareStatement("insert into db_test\n" +                                         "(theId)\n" +                                         "values\n" +                                         "(1)");            insertStmt.executeUpdate();            fail("Using garbage connection info should have caused error");        } catch (SQLException e) {            // Normally the job of parsing the SQLException and re-throwing            // the right type is handled by code in the pool or buried in DB.            // However, here we're using straight JDBC, so we need to explicitly            // cause the parsing to happen.            SQLException wrapped = SQLExceptionHandler.wrap(e);            if (wrapped instanceof DbNotAvailableException) {                // good            } else {                fail("Setting garbage connection info should have caused " +                     "DbNotAvailableException, instead caused " + wrapped);            }        }    }