// that it's seen and prints a report of missing links at the end.
package main

import (
	"errors"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"regexp"
	"strings"
	"sync"
)

var (
	root    = flag.String("root", "http://localhost:6060", "Root to crawl")
	verbose = flag.Bool("verbose", false, "verbose")
)

The patterns used by [ServeMux] allow multiple spaces matching

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

package swig

import (
	"cmd/internal/quoted"
	"internal/testenv"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	"sync"
	"testing"
)

func TestStdio(t *testing.T) {
	testenv.MustHaveCGO(t)
	mustHaveSwig(t)
	run(t, "testdata/stdio", false)
}

func TestCall(t *testing.T) {

pkg regexp, method (*Regexp) Longest()
pkg regexp, method (*Regexp) Split(string, int) []string
pkg regexp/syntax, const ClassNL = 4
pkg regexp/syntax, const DotNL = 8
pkg regexp/syntax, const EmptyBeginLine = 1
pkg regexp/syntax, const EmptyBeginText = 4
pkg regexp/syntax, const EmptyEndLine = 2
pkg regexp/syntax, const EmptyEndText = 8
pkg regexp/syntax, const EmptyNoWordBoundary = 32

		t.Errorf("want output %q, got %q", want, got)
	}
	if want := 1; want != code {
		t.Errorf("want exit code %d, got %d", want, code)
	}
}

func TestExitCodeMissing(t *testing.T) {
	var wantErr *regexp.Regexp
	check := func(text string) {
		t.Helper()
		var out strings.Builder
		f, exitStr := newExitCodeFilter(&out)
		if want := "exitcode="; want != exitStr {

0000190 00 00 00 00 00 00 00 00 00 00 00 72 2f 72 2e 7a
00001a0 69 70 50 4b 05 06 00 00 00 00 01 00 01 00 35 00
00001b0 00 00 6d 01 00 00 00 00`
	s = regexp.MustCompile(`[0-9a-f]{7}`).ReplaceAllString(s, "")
	s = regexp.MustCompile(`\s+`).ReplaceAllString(s, "")
	b, err := hex.DecodeString(s)
	if err != nil {
		panic(err)
	}
	return b
}

pkg net/url, method (*Error) Timeout() bool
pkg net/url, method (InvalidHostError) Error() string
pkg net/url, type InvalidHostError string
pkg os/exec, type ExitError struct, Stderr []uint8
pkg regexp, method (*Regexp) Copy() *Regexp
pkg runtime/debug, func SetTraceback(string)
pkg strconv, func AppendQuoteRuneToGraphic([]uint8, int32) []uint8
pkg strconv, func AppendQuoteToGraphic([]uint8, string) []uint8

	close(quit)
	return code, err
}

type exitCodeFilter struct {
	w      io.Writer // Pass through to w
	exitRe *regexp.Regexp
	buf    bytes.Buffer
}

func newExitCodeFilter(w io.Writer) (*exitCodeFilter, string) {
	const exitStr = "exitcode="

	// Build a regexp that matches any prefix of the exit string at the end of
	// the input. We do it this way to avoid assuming anything about the

pkg regexp/syntax, method (*Prog) String() string
pkg regexp/syntax, method (*Regexp) CapNames() []string
pkg regexp/syntax, method (*Regexp) Equal(*Regexp) bool
pkg regexp/syntax, method (*Regexp) MaxCap() int
pkg regexp/syntax, method (*Regexp) Simplify() *Regexp
pkg regexp/syntax, method (*Regexp) String() string
pkg regexp/syntax, method (ErrorCode) String() string
pkg regexp/syntax, type EmptyOp uint8

pkg net/url, method (*URL) Redacted() string
pkg net/url, type URL struct, RawFragment string
pkg os, method (*File) ReadFrom(io.Reader) (int64, error)
pkg os, var ErrDeadlineExceeded error
pkg regexp, method (*Regexp) SubexpIndex(string) int
pkg strconv, func FormatComplex(complex128, uint8, int, int) string
pkg strconv, func ParseComplex(string, int) (complex128, error)