}

    public void setMyProperty(String value) {
        myProp = value;
    }

    public void setMyProperty(Object value) {
        myProp = value.toString();
    }

    public void throwsException() {
        throw failure;
    }

    static class TestCheckedException extends Exception {
        public TestCheckedException(Throwable cause) {
            super(cause);
        }
    }

    }

    public void setParamProperty() {
    }

    public void setParamProperty(String param, String someOther) {
    }

    public void setWriteOnly(String param) {
    }

    public void throwsException() {
        throw failure;
    }

    static class TestCheckedException extends Exception {
        public TestCheckedException(Throwable cause) {
            super(cause);
        }
    }

        !JavaMethod.of(myProperties.class, String, "getMyProperty").isStatic()
    }

    def "call failing methods reflectively"() {
        when:
        JavaMethod.of(myProperties.class, Void, "throwsException").invoke(myProperties)

        then:
        IllegalStateException e = thrown()
        e == myProperties.failure

        when:

        and:
        def e = thrown(thrownException)
        exception == thrownException || e.cause.class == exception

        when:
        hasher.hash(zipContext)

        then:
        1 * delegate.hash(zipContext) >> { throw exception.getDeclaredConstructor().newInstance() }

        and:
        e = thrown(thrownException)
        exception == thrownException || e.cause.class == exception

        where:

        GradleException thrownException = null

        when:
        executer.execute(task, state, executionContext)

        then:
        1 * spec.findUnsatisfiedSpec(task) >> { throw failure }
        1 * state.setOutcome(_ as Throwable) >> { args -> thrownException = args[0] }
        noMoreInteractions()

        thrownException.message.startsWith('Could not evaluate onlyIf predicate for')

    try {
      try {
        throw thrownException;
      } catch (Throwable e) {
        throw closer.rethrow(thrownException, IOException.class);
      } finally {
        assertThat(thrownException.getSuppressed()).isEmpty();
        closer.close();
      }
    } catch (IOException expected) {
      assertSame(thrownException, expected);
    }

    assertTrue(c1.isClosed());

        assertNotNull(bean.myBean.getAnotherBean());
        assertSame(bean.myBean.getAnotherBean().getClass(), AnotherBean.class);
        assertThrows(TestException.class, () -> bean.myBean.throwException());
    }

    @Named
    static class MySingletonBean {
        @Inject
        @Named("scoped")
        BeanItf myBean;

        @Inject
        @Named("another")
        BeanItf2 anotherBean;

    public static final String BUILD_ACTION_EXCEPTION_MESSAGE = "Something went wrong when executing the build action";

    public String execute(BuildController controller) {
        throwException();
        return "";
    }

    abstract void throwException();

        then:
        1 * delegate.hash(snapshot) >> { throw exception.getDeclaredConstructor().newInstance() }

        and:
        def e = thrown(thrownException)
        exception == thrownException || e.cause.class == exception

        where:
        exception        | thrownException
        IOException      | UncheckedIOException
        RuntimeException | RuntimeException
    }

    File file(String path) {

  protected volatile boolean throwException = false;

  protected final ListenableFutureTask<Integer> task =
      ListenableFutureTask.create(
          new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
              runLatch.countDown();
              taskLatch.await();
              if (throwException) {
                throw new IllegalStateException("Fail");