B75                           = 0x2
	B9600                         = 0xd
	BRKINT                        = 0x2
	BS0                           = 0x0
	BS1                           = 0x1000
	BSDLY                         = 0x1000
	CAP_AACCT                     = 0x6
	CAP_ARM_APPLICATION           = 0x5
	CAP_BYPASS_RAC_VMM            = 0x3
	CAP_CLEAR                     = 0x0
	CAP_CREDENTIALS               = 0x7

	B75                           = 0x2
	B9600                         = 0xd
	BRKINT                        = 0x2
	BS0                           = 0x0
	BS1                           = 0x1000
	BSDLY                         = 0x1000
	CAP_AACCT                     = 0x6
	CAP_ARM_APPLICATION           = 0x5
	CAP_BYPASS_RAC_VMM            = 0x3
	CAP_CLEAR                     = 0x0
	CAP_CREDENTIALS               = 0x7

		return "", fmt.Errorf("no path for %v", obj)

	case *types.Var:
		// Could be:
		// - a field (obj.IsField())
		// - a func parameter or result
		// - a local var.
		// Sadly there is no way to distinguish
		// a param/result from a local
		// so we must proceed to the find.

	case *types.Func:
		// A func, if not package-level, must be a method.

	output := runTestProg(t, "testprog", "BadTraceback")
	for _, want := range []string{
		"unexpected return pc",
		"called from 0xbad",
		"00000bad",    // Smashed LR in hex dump
		"<main.badLR", // Symbolization in hex dump (badLR1 or badLR2)
	} {
		if !strings.Contains(output, want) {
			t.Errorf("output does not contain %q:\n%s", want, output)
		}
	}
}

func TestTimePprof(t *testing.T) {

		default:
			panic(fmt.Sprintf("internal error: invalid kind %v", kind))
		}
		if !ok {
			return fmt.Errorf("invalid char %q", r)
		}
	}

	// Windows disallows a bunch of path elements, sadly.
	// See https://docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file
	short := elem
	if i := strings.Index(short, "."); i >= 0 {
		short = short[:i]
	}
	for _, bad := range badWindowsNames {

	BPF_X                                   = 0x8
	BRKINT                                  = 0x2
	BS0                                     = 0x0
	BS1                                     = 0x8000
	BSDLY                                   = 0x8000
	CFLUSH                                  = 0xf
	CLOCAL                                  = 0x8000
	CLOCK_MONOTONIC                         = 0x6

	BPF_W                         = 0x0
	BPF_X                         = 0x8
	BRKINT                        = 0x2
	BS0                           = 0x0
	BS1                           = 0x2000
	BSDLY                         = 0x2000
	CBAUD                         = 0xf
	CFLUSH                        = 0xf
	CIBAUD                        = 0xf0000
	CLOCAL                        = 0x800

    // feature, exactly, but unavoidable (I think) and harmless
    Ordering<Integer> l = objects.compound(numbers);

    // This correctly doesn't work:
    // Ordering<Object> m = numbers.compound(objects);

    // Sadly, the following works in javac 1.6, but at least it fails for
    // eclipse, and is *correctly* highlighted red in IDEA.
    // Ordering<Object> n = objects.compound(numbers);
  }

  public void testReverse() {

	BPF_X                                   = 0x8
	BRKINT                                  = 0x2
	BS0                                     = 0x0
	BS1                                     = 0x8000
	BSDLY                                   = 0x8000
	CFLUSH                                  = 0xf
	CLOCAL                                  = 0x8000
	CLOCK_MONOTONIC                         = 0x6

		return urlErr.Timeout()
	}
	return false
}

func isStreamReset(err error) bool {
	if err == nil {
		return false
	}
	if urlErr, ok := err.(*url.Error); ok {
		// Sadly, the client does not receive a more specific indication
		// of stream reset.
		return strings.Contains(urlErr.Err.Error(), "INTERNAL_ERROR")
	}
	return false
}