}

	const srcPath = `alldocs.go`
	old, err := os.ReadFile(srcPath)
	if err != nil {
		t.Fatalf("error reading %s: %v", srcPath, err)
	}
	diff := diff.Diff(srcPath, old, "go help documentation | gofmt", alldocs)
	if diff == nil {
		t.Logf("%s is up to date.", srcPath)
		return
	}

	if *fixDocs {
		if err := os.WriteFile(srcPath, alldocs, 0666); err != nil {
			t.Fatal(err)
		}

-- input --
The Go home page is https://go.dev/.
It used to be https://golang.org.
https:// is not a link.
Nor is https://
https://☺ is not a link.
https://:80 is not a link.

-- gofmt --
The Go home page is https://go.dev/.
It used to be https://golang.org.
https:// is not a link.
Nor is https://
https://☺ is not a link.
https://:80 is not a link.

-- text --

	exit 1
	;;
esac

(
	if [ -n "$mkerrors" ]; then echo "$mkerrors |gofmt >$zerrors"; fi
	syscall_goos="syscall_$GOOS.go"
 	case "$GOOS" in
	darwin | dragonfly | freebsd | netbsd | openbsd)
		syscall_goos="syscall_bsd.go $syscall_goos"
 		;;
 	esac
	if [ -n "$mksyscall" ]; then echo "$mksyscall -tags $GOOS,$GOARCH $syscall_goos $GOOSARCH_in |gofmt >zsyscall_$GOOSARCH.go"; fi

				isMapIndex(pass.TypesInfo, lhs) {
				continue // expressions may not be equal
			}
			if reflect.TypeOf(lhs) != reflect.TypeOf(rhs) {
				continue // short-circuit the heavy-weight gofmt check
			}
			le := analysisutil.Format(pass.Fset, lhs)
			re := analysisutil.Format(pass.Fset, rhs)
			if le == re {
				pass.Report(analysis.Diagnostic{

// (limited by the size of fd_set).
//
// Go does not use select, so it should not be subject to these limits.
// On some systems the limit is 256, which is very easy to run into,
// even in simple programs like gofmt when they parallelize walking
// a file tree.
//
// After a long discussion on go.dev/issue/46279, we decided the
// best approach was for Go to raise the limit unconditionally for itself,

	case goos == "freebsd":
		// Keep pre-FreeBSD 10 / non-POSIX 2008 names for timespec fields
		re := regexp.MustCompile("(A|M|C|Birth)tim\\s+Timespec")
		s = re.ReplaceAllString(s, "${1}timespec Timespec")
	}

	// gofmt
	b, err = format.Source([]byte(s))
	if err != nil {
		log.Fatal(err)
	}

	// Append this command to the header to show where the new file
	// came from.

	}

	tmplOut := new(bytes.Buffer)
	tmpl := template.Must(template.New("zosarch").Parse(zosarchTmpl))
	err = tmpl.Execute(tmplOut, entries)
	if err != nil {
		t.Fatal(err)
	}

	cmd = testenv.Command(t, "gofmt")
	cmd.Stdin = bytes.NewReader(tmplOut.Bytes())
	want, err := cmd.Output()
	if err != nil {
		t.Logf("stdin:\n%s", tmplOut.Bytes())
		if ee, ok := err.(*exec.ExitError); ok && len(ee.Stderr) > 0 {

And https://example.com/[foo]/bar{.
And https://example.com/(foo)/bar!
And https://example.com/{foo}/bar{.
And https://example.com/)baz{foo}.

[And https://example.com/].

-- gofmt --
URLs with punctuation are hard.
We don't want to consume the end-of-sentence punctuation.

For example, https://en.wikipedia.org/wiki/John_Adams_(miniseries).
And https://example.com/[foo]/bar{.

  - type: input
    id: go-toolchain
    attributes:
      label: Changes to Go ToolChain
      description: "How many tools (such as vet, gopls, gofmt, goimports, etc.) would be affected? "
    validations:
      required: false

  - type: input
    id: perf-costs
    attributes:
      label: Performance Costs

	for _, s := range sizes {
		fmt.Fprintf(w, "  testCopy%d(t)\n", s)
	}
	for _, s := range usizes {
		fmt.Fprintf(w, "  testUnalignedCopy%d(t)\n", s)
	}
	fmt.Fprintf(w, "}\n")

	// gofmt result
	b := w.Bytes()
	src, err := format.Source(b)
	if err != nil {
		fmt.Printf("%s\n", b)
		panic(err)
	}

	// write to file
	err = os.WriteFile("../copy_test.go", src, 0666)
	if err != nil {