String keyId = request.queryString - "op=get&options=mr&search=0x"
                    if (KeyServer.this.keyFiles.containsKey(keyId)) {
                        KeyServer.this.fileHandler("/pks/lookup", KeyServer.this.keyFiles[keyId]).handle(request, response)
                    } else {
                        response.sendError(404, "not found")
                    }
                }

	b.SetBytes(int64(len(src)))
	for i := 0; i < b.N; i++ {
		if _, err := ParseFile(token.NewFileSet(), "", src, ParseComments); err != nil {
			b.Fatalf("benchmark failed due to parse error: %s", err)
		}
	}
}

func BenchmarkParseOnly(b *testing.B) {
	b.SetBytes(int64(len(src)))
	for i := 0; i < b.N; i++ {
		if _, err := ParseFile(token.NewFileSet(), "", src, ParseComments|SkipObjectResolution); err != nil {

        """)
    }

    @Override
    String getExpectedOutput() {
        return greeter.expectedOutput + sum.sum(5, 7)
    }

    @Override
    List<SourceFile> getFiles() {
        return super.getFiles() + sum.getFiles()
    }

const (
	// BlockValueStyle is the default string encoding which preserves whitespace and newlines.
	BlockValueStyle EncodeStyle = iota

	// FlowValueStyle indicates that the string is an inline representation of complex types.
	FlowValueStyle

	// FoldedValueStyle is a multiline string with whitespace and newlines trimmed to a single
	// a whitespace. Repeated newlines are replaced with a single newline rather than a single
	// whitespace.

WD=$(dirname "$0")
WD=$(cd "$WD"; pwd)

for fn in "$@"; do
  if ! grep -L -q -e "Apache License, Version 2" -e "Copyright" "${fn}"; then
    if [[ "${fn}" == *.go || "${fn}" == *.rs ]]; then
      newfile=$(cat "${WD}/copyright-banner-go.txt" "${fn}")
      echo "${newfile}" > "${fn}"
      echo "Fixing license: ${fn}"
    else
      echo "Cannot fix license: ${fn}. Unknown file type"
    fi
  fi

func TestNewFileNonBlock(t *testing.T) {
	t.Parallel()
	newFileTest(t, false)
}

func TestNewFileInvalid(t *testing.T) {
	t.Parallel()
	const negOne = ^uintptr(0)
	if f := NewFile(negOne, "invalid"); f != nil {
		t.Errorf("NewFile(-1) got %v want nil", f)
	}
}

func TestSplitPath(t *testing.T) {
	t.Parallel()
	for _, tt := range []struct{ path, wantDir, wantBase string }{
		{"a", ".", "a"},

        assert other.source == source;

        BitSet newFilter = new BitSet(source.size());
        newFilter.or(filter);
        newFilter.clear(other.getSourceIndex(index));
        return new ImmutableFilteredList<T>(source, newFilter);
    }

    /**
     * Returns a new list which contains all items in this list which match the provided {@code matcher}.
     */

            label.newLineAdjustment();
        }
    }

    public void redraw(AnsiContext ansi) {
        int newLines = 0 - statusAreaPos.row + getHeight() - 1;
        if (isVisible && newLines > 0) {
            ansi.cursorAt(Cursor.newBottomLeft()).newLines(newLines);
        }

        // Redraw every entry of this area
        for (int i = 0; i < entries.size(); ++i) {

        if (filesMetadata.getFiles().isEmpty()) {
            return declaredFiles;
        }
        ImmutableList.Builder<T> builder = new ImmutableList.Builder<>();
        if (!filesMetadata.isClearExistingFiles()) {
            builder.addAll(declaredFiles);
        }
        for (VariantFileMetadata file : filesMetadata.getFiles()) {

}

// getWorkerComm returns communication channels in the worker process.
func getWorkerComm() (comm workerComm, err error) {
	fuzzIn := os.NewFile(3, "fuzz_in")
	fuzzOut := os.NewFile(4, "fuzz_out")
	memFile := os.NewFile(5, "fuzz_mem")
	fi, err := memFile.Stat()
	if err != nil {
		return workerComm{}, err
	}
	size := int(fi.Size())
	if int64(size) != fi.Size() {