case Stopped:
                case ForceStopped:
                    throw new DaemonStoppedException(stopReason);
                case Broken:
                    throw new DaemonUnavailableException("This daemon is broken and will stop.");
                default:
                    throw new IllegalStateException("Daemon is in unexpected state: " + state);
            }
        } finally {

        }
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        }
        if (t instanceof Error) {
            throw (Error) t;
        }
        if (t instanceof IOException) {
            if (preserveMessage) {
                throw new UncheckedIOException(t.getMessage(), t);
            } else {
                throw new UncheckedIOException(t);
            }
        }

        long expected = units.toMillis(value);
        if (actual < expected - 200) {
            throw new RuntimeException(String.format(
                    "Action did not block for expected time. Expected ~ %d ms, was %d ms.", expected, actual));
        }
        if (actual > expected + 1200) {
            throw new RuntimeException(String.format(

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

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

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

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

      @CheckForNull Object p4) {
    if (reference == null) {
      throw new NullPointerException(lenientFormat(errorMessageTemplate, p1, p2, p3, p4));
    }
    return reference;
  }

  /*
   * All recent hotspots (as of 2009) *really* like to have the natural code
   *
   * if (guardExpression) {
   *    throw new BadException(messageExpression);
   * }
   *

func msanread(addr unsafe.Pointer, sz uintptr)     { throw("msan") }
func msanwrite(addr unsafe.Pointer, sz uintptr)    { throw("msan") }
func msanmalloc(addr unsafe.Pointer, sz uintptr)   { throw("msan") }
func msanfree(addr unsafe.Pointer, sz uintptr)     { throw("msan") }

            throw e;
        } catch (Exception e) {
            throw new UncheckedIOException(e);
        }
    }

    @Override
    public void write(BlockPayload block) {
        BlockImpl blockImpl = (BlockImpl) block.getBlock();
        try {
            blockImpl.write();
        } catch (CorruptedCacheException e) {
            throw e;
        } catch (Exception e) {

    def "produces reasonable error message when build fails and Gradle.buildFinished closure also fails"() {
        buildFile << """
    gradle.buildFinished {
        throw new RuntimeException('broken closure')
    }
    task broken {
        doLast { throw new RuntimeException('broken task') }
    }
"""

        when:
        fails("broken")

        then:
        failure.assertHasFailures(2)

      @CheckForNull Object p4) {
    if (reference == null) {
      throw new NullPointerException(lenientFormat(errorMessageTemplate, p1, p2, p3, p4));
    }
    return reference;
  }

  /*
   * All recent hotspots (as of 2009) *really* like to have the natural code
   *
   * if (guardExpression) {
   *    throw new BadException(messageExpression);
   * }
   *

        throw new UnsupportedOperationException("Cannot change the version information for an attached artifact."
                + " It is derived from the main artifact.");
    }

    public String getBaseVersion() {
        return parent.getBaseVersion();
    }

    public void setBaseVersion(String baseVersion) {