b := NewReaderSize(strings.NewReader("hello world"), BufSize)
	// Does it recognize itself?
	b1 := NewReaderSize(b, BufSize)
	if b1 != b {
		t.Error("NewReaderSize did not detect underlying Reader")
	}
	// Does it wrap if existing buffer is too small?
	b2 := NewReaderSize(b, 2*BufSize)
	if b2 == b {
		t.Error("NewReaderSize did not enlarge buffer")
	}
}

func TestNewWriterSizeIdempotent(t *testing.T) {

the <a href="#Numeric_types">unsigned integer</a>'s type.
Loosely speaking, these unsigned integer operations
discard high bits upon overflow, and programs may rely on "wrap around".
</p>
<p>
For signed integers, the operations <code>+</code>,
<code>-</code>, <code>*</code>, <code>/</code>, and <code>&lt;&lt;</code> may legally

	// C data with explicit length to Go []byte
	func C.GoBytes(unsafe.Pointer, C.int) []byte

As a special case, C.malloc does not call the C library malloc directly
but instead calls a Go helper function that wraps the C library malloc
but guarantees never to return nil. If C's malloc indicates out of memory,
the helper function crashes the program, like when Go itself runs out

pkg syscall (netbsd-arm64-cgo), const IFT_AFLANE8025 = 60
pkg syscall (netbsd-arm64-cgo), const IFT_AFLANE8025 ideal-int
pkg syscall (netbsd-arm64-cgo), const IFT_ARAP = 88
pkg syscall (netbsd-arm64-cgo), const IFT_ARAP ideal-int
pkg syscall (netbsd-arm64-cgo), const IFT_ARCNET = 35
pkg syscall (netbsd-arm64-cgo), const IFT_ARCNET ideal-int
pkg syscall (netbsd-arm64-cgo), const IFT_ARCNETPLUS = 36

computed modulo 2<sup><i>n</i></sup>, where <i>n</i> is the bit width of
the unsigned integer's type.
Loosely speaking, these unsigned integer operations
discard high bits upon overflow, and programs may rely on "wrap around".
</p>

<p>
For signed integers, the operations <code>+</code>,
<code>-</code>, <code>*</code>, <code>/</code>, and <code>&lt;&lt;</code> may legally

			if 'A' <= sr && sr <= 'Z' && tr == sr+'a'-'A' {
				continue
			}
			return false
		}

		// General case. SimpleFold(x) returns the next equivalent rune > x
		// or wraps around to smaller values.
		r := unicode.SimpleFold(sr)
		for r != sr && r < tr {
			r = unicode.SimpleFold(r)
		}
		if r == tr {
			continue
		}
		return false
	}

pkg syscall (freebsd-386), const IFT_ADSL = 94
pkg syscall (freebsd-386), const IFT_AFLANE8023 = 59
pkg syscall (freebsd-386), const IFT_AFLANE8025 = 60
pkg syscall (freebsd-386), const IFT_ARAP = 88
pkg syscall (freebsd-386), const IFT_ARCNET = 35
pkg syscall (freebsd-386), const IFT_ARCNETPLUS = 36
pkg syscall (freebsd-386), const IFT_ASYNC = 84
pkg syscall (freebsd-386), const IFT_ATM = 37

pkg syscall (freebsd-386-cgo), const IFT_ADSL ideal-int
pkg syscall (freebsd-386-cgo), const IFT_AFLANE8023 ideal-int
pkg syscall (freebsd-386-cgo), const IFT_AFLANE8025 ideal-int
pkg syscall (freebsd-386-cgo), const IFT_ARAP ideal-int
pkg syscall (freebsd-386-cgo), const IFT_ARCNET ideal-int
pkg syscall (freebsd-386-cgo), const IFT_ARCNETPLUS ideal-int
pkg syscall (freebsd-386-cgo), const IFT_ASYNC ideal-int

	// to _cgoCheckPointer, as done in checkIndex and checkAddr.
	//
	// When the function argument is a conversion to unsafe.Pointer,
	// we unwrap the conversion before checking the pointer,
	// and then wrap again when calling C.f. This lets us check
	// the real type of the pointer in some cases. See issue #25941.
	//
	// When the call to C.f is deferred, we use an additional function

		}
		if v.wantErr == nil && r.Len() == 0 {
			t.Errorf("test %d, canary byte unexpectedly consumed", i)
		}
	}
}

// testNonEmptyReader wraps an io.Reader and ensures that
// Read is never called with an empty buffer.
type testNonEmptyReader struct{ io.Reader }

func (r testNonEmptyReader) Read(b []byte) (int, error) {
	if len(b) == 0 {