class DefaultMultiCauseExceptionIntegrationTest  extends AbstractIntegrationSpec {
    def 'when tasks throw exceptions that offer resolutions, those resolutions are included'() {
        given:
        buildFile << """
            ${defineTestException()}

            tasks.register('myTask') {
                doLast {
                    throw new TestResolutionProviderException('resolution1')
                }
            }
        """

            return spf;
        } catch (ParserConfigurationException e) {
            throw new RuntimeException(errorMessageFor("SAXParserFactory"), e);
        } catch (SAXNotSupportedException e) {
            throw new RuntimeException(errorMessageFor("SAXParserFactory"), e);
        } catch (SAXNotRecognizedException e) {
            throw new RuntimeException(errorMessageFor("SAXParserFactory"), e);
        }
    }

        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        } catch (IllegalAccessException e) {
            throw new IllegalAccessError(e.getMessage());
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    public MetaClassAdapter determineDelegate(Object bean) {

                        thread = null;
                        throw new TransportException( "Connection timeout" );
                    case 2:
                        if (te != null) { /* doConnect throw Exception */
                            state = 4;                        /* error */
                            thread = null;
                            throw te;
                        }

   * types your try block can throw when calling an overload of this method so as to avoid losing
   * the original exception type.
   *
   * <p>This method always throws, and as such should be called as {@code throw closer.rethrow(e);}
   * to ensure the compiler knows that it will throw.
   *
   * @return this method does not return; it always throws

    public T next() {
      try {
        return iterator.next();
      } catch (NoSuchElementException e) {
        nextThrewException = true;
        throw e;
      }
    }

    @Override
    public void remove() {
      if (nextThrewException) {
        throw new IllegalStateException();
      }
      iterator.remove();
    }
  }

  public void testCanCatchSunJavaBug6529795InTargetIterator() {

                    disconnect(true);
                    throw new NbtException(NbtException.ERR_SSN_SRVC, errorCode);
                }
                break;
            case -1:
                disconnect(true);
                throw new NbtException(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED);
            default:
                disconnect(true);
                throw new NbtException(NbtException.ERR_SSN_SRVC, 0);

                    throw new SmbUnsupportedOperationException();
                }
                throw e;
            }
            try ( SmbFile browser = (SmbFile) parent.resolve(addr.getHostAddress()) ) {
                try ( SmbTreeHandleImpl th = browser.ensureTreeConnected() ) {
                    if ( th.isSMB2() ) {
                        throw new SmbUnsupportedOperationException();

   * types your try block can throw when calling an overload of this method so as to avoid losing
   * the original exception type.
   *
   * <p>This method always throws, and as such should be called as {@code throw closer.rethrow(e);}
   * to ensure the compiler knows that it will throw.
   *
   * @return this method does not return; it always throws

        expectGetMissing()
    }

    @Override
    void expectMetadataRetrieve() {
        throw new UnsupportedOperationException()
    }

    @Override
    void expectMetadataRetrieveMissing() {
        throw new UnsupportedOperationException()
    }

    @Override
    void expectMetadataRetrieveBroken() {
        throw new UnsupportedOperationException()
    }

    @Override
    void expectParentMkdir() {