@Override
    public void execute(T thing) {
        try {
            doExecute(thing);
        } catch (Exception e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    protected abstract void doExecute(T thing) throws Exception;

import spock.lang.Specification

class ErroringActionTest extends Specification {

    def "checked exceptions are wrapped"() {
        when:
        new ErroringAction() {
            @Override
            void doExecute(Object thing) {
                throw new Exception()
            }
        }.execute("foo")

        then:
        thrown(RuntimeException)
    }

    def "unchecked exceptions are passed through"() {

                @Override
                protected void doExecute(SimpleHtmlWriter writer) throws IOException {
                    renderPackages(writer);
                }
            });
        }
        addTab("Classes", new ErroringAction<SimpleHtmlWriter>() {
            @Override
            public void doExecute(SimpleHtmlWriter htmlWriter) throws IOException {
                renderClasses(htmlWriter);

        }
    }

    @Override
    protected void registerTabs() {
        addFailuresTab();
        addTab("Tests", new ErroringAction<SimpleHtmlWriter>() {
            @Override
            public void doExecute(SimpleHtmlWriter writer) throws IOException {
                renderTests(writer);
            }
        });
        final long classId = getModel().getId();

            public
            override fun doExecute(bufferedWriter: BufferedWriter) {
                val packages = Implementation(excludes.get()).collectPackages(classpath.files.map(File::toPath))
                packages.dump(false, object : ErroringAction<String>() {
                    @Throws(Exception::class)
                    override fun doExecute(s: String) {
                        bufferedWriter.write(s)

        this.inputChanges = inputChanges;
    }

    @Override
    public void clearInputChanges() {
        this.inputChanges = null;
    }

    @Override
    protected void doExecute(Task task, String methodName) {
        JavaMethod.of(task, Object.class, methodName, InputChanges.class).invoke(task, inputChanges);
    }

        server.expect(server.post(backingRepo.getName() + "/git-upload-pack", new ErroringAction<HttpExchange>() {
            @Override
            protected void doExecute(HttpExchange httpExchange) throws Exception {
                httpExchange.getResponseHeaders().add("content-type", "application/x-git-upload-pack-result");
                httpExchange.sendResponseHeaders(200, 0);

    protected void addFailuresTab() {
        if (!results.getFailures().isEmpty()) {
            addTab("Failed tests", new ErroringAction<SimpleHtmlWriter>() {
                @Override
                public void doExecute(SimpleHtmlWriter element) throws IOException {
                    renderFailures(element);
                }
            });
        }
    }

        LOGGER.debug("parsing maven-metadata: {}", metadataResource);
        metadataResource.withContent(new ErroringAction<InputStream>() {
            @Override
            public void doExecute(InputStream inputStream) throws ParserConfigurationException, SAXException, IOException {
                XMLHelper.parse(inputStream, null, new ContextualSAXHandler() {
                    @Override

func (re *Regexp) doMatch(r io.RuneReader, b []byte, s string) bool {
	return re.doExecute(r, b, s, 0, 0, nil) != nil
}

// doExecute finds the leftmost match in the input, appends the position
// of its subexpressions to dstCap and returns dstCap.
//
// nil is returned if no matches are found and non-nil if matches are found.
func (re *Regexp) doExecute(r io.RuneReader, b []byte, s string, pos int, ncap int, dstCap []int) []int {