if err != nil {
		return []string{name}
	}
	return []string{executor, name}
}

// genHeader writes a C header file for the C-exported declarations found in .go
// source files in dir.
//
// TODO(golang.org/issue/35715): This should be simpler.
func genHeader(t *testing.T, header, dir string) {
	t.Helper()

	// The 'cgo' command generates a number of additional artifacts,

            @Override
            public void execute(@Nonnull PrefixHeaderFileParameters parameters) {
                parameters.getHeader().set(header);
                parameters.getPrefixHeaderFile().set(prefixHeaderFile);
            }
        });
    }

    @Input
    public String getHeader() {
        return header;
    }

    public void setHeader(String header) {
        this.header = header;
    }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package foo_test

import (
	"bytes"
	"io"
)

func getReader() io.Reader { return nil }

func do(b bytes.Reader) {}

func Example() {
	getReader()
	do()
	// Output:
}

func ExampleIgnored() {

-- .Play --
package main

import (
	"bytes"
	"io"
)

func getReader() io.Reader { return nil }

func do(b bytes.Reader) {}

func main() {
	getReader()
	do()
}
-- Ignored.Play --
package main

import ()

func main() {

        String responseHeader = response.getHeader(HttpHeaders.LAST_MODIFIED);
        if (responseHeader == null) {
            return new Date(0);
        }
        try {
            return DateUtils.parseDate(responseHeader);
        } catch (Exception e) {
            return new Date(0);
        }
    }

    private String getFilename() {
        String disposition = response.getHeader("Content-Disposition");

 */
public abstract class CppSourceFileElement extends CppLibraryElement {
    public abstract SourceFileElement getHeader();

    public abstract SourceFileElement getSource();

    @Override
    public SourceElement getPublicHeaders() {
        return getHeader();
    }

    @Override
    public SourceElement getSources() {
        return getSource();
    }

        this.readers = new ConcurrentHashMap<Thread, TestOutputStore.Reader>();
    }

    protected void withReader(Action<TestOutputStore.Reader> action) {
        action.execute(getReader());
    }

    private TestOutputStore.Reader getReader() {
        Thread thread = Thread.currentThread();
        TestOutputStore.Reader reader = readers.get(thread);
        if (reader == null) {
            reader = outputStore.reader();

        Map<String, String> entries = request.getHeaderNames().toList().collectEntries { headerName -> [headerName, request.getHeader(headerName as String)] }
        allHeaders.add(entries)
        String authorization = getAuthorizationHeader(request)
        if (authorization != null) {
            synchronized (authenticationAttempts) {

            void handle(HttpServletRequest request, HttpServletResponse response) {
                request.getHeader("X-Gradle-Version") == "3.0"

                def accept = request.getHeader(HttpHeaders.ACCEPT).split(", ")
                assert accept.length == 2
                assert accept[0] == HttpBuildCacheService.BUILD_CACHE_CONTENT_TYPE

    private final Object header;

    public SerializedPayload(Object header, List<byte[]> serializedModel) {
        this.header = header;
        this.serializedModel = serializedModel;
    }

    public Object getHeader() {
        return header;
    }

    public List<byte[]> getSerializedModel() {
        return serializedModel;
    }