func ExampleWriter_ReadFrom() {
	var buf bytes.Buffer
	writer := bufio.NewWriter(&buf)

	data := "Hello, world!\nThis is a ReadFrom example."
	reader := strings.NewReader(data)

	n, err := writer.ReadFrom(reader)
	if err != nil {
		fmt.Println("ReadFrom Error:", err)
		return
	}

	if err = writer.Flush(); err != nil {
		fmt.Println("Flush Error:", err)

pkg go/parser, const ParseComments = 4
pkg go/parser, const SpuriousErrors = 32
pkg go/parser, const Trace = 8
pkg go/printer, const RawFormat = 1
pkg go/printer, const SourcePos = 8
pkg go/printer, const TabIndent = 2
pkg go/printer, const UseSpaces = 4
pkg go/printer, type Config struct, Indent int
pkg go/scanner, const ScanComments = 1
pkg go/token, const ADD = 12
pkg go/token, const ADD_ASSIGN = 23

pkg net/netip, method (Prefix) String() string
pkg net/netip, type Addr struct
pkg net/netip, type AddrPort struct
pkg net/netip, type Prefix struct
pkg reflect, const Pointer = 22
pkg reflect, const Pointer Kind
pkg reflect, func PointerTo(Type) Type
pkg reflect, method (*MapIter) Reset(Value)
pkg reflect, method (Value) CanComplex() bool
pkg reflect, method (Value) CanFloat() bool

	// the following are updated on every cleanup defined in lockValidityDuration
	readers         atomic.Int32
	writers         atomic.Int32
	lastCleanup     atomic.Pointer[time.Time]
	locksOverloaded atomic.Int64
}

// getMutex will lock the mutex.
// Call the returned function to unlock.
func (l *localLocker) getMutex() func() {
	l.waitMutex.Add(1)
	l.mutex.Lock()
	l.waitMutex.Add(-1)

pkg reflect, method (StructTag) Lookup(string) (string, bool)
pkg runtime, func CallersFrames([]uintptr) *Frames
pkg runtime, func KeepAlive(interface{})
pkg runtime, func SetCgoTraceback(int, unsafe.Pointer, unsafe.Pointer, unsafe.Pointer)
pkg runtime, method (*Frames) Next() (Frame, bool)
pkg runtime, type Frame struct
pkg runtime, type Frame struct, Entry uintptr
pkg runtime, type Frame struct, File string

Ian Lance Taylor <******@****.***> 1765577893 -0800

                    BuildStep after = plan.requiredStep(project, AFTER + phase.name());
                    Lifecycle.Pointer pointer = link.pointer();
                    String n2 = pointer.phase();
                    if (pointer instanceof Lifecycle.DependenciesPointer) {
                        // For dependencies: ensure current project's phase starts after dependency's phase completes

pkg mime/quotedprintable, func NewWriter(io.Writer) *Writer
pkg mime/quotedprintable, method (*Reader) Read([]uint8) (int, error)
pkg mime/quotedprintable, method (*Writer) Close() error
pkg mime/quotedprintable, method (*Writer) Write([]uint8) (int, error)
pkg mime/quotedprintable, type Reader struct
pkg mime/quotedprintable, type Writer struct
pkg mime/quotedprintable, type Writer struct, Binary bool

		return true
	}
	return false
}

// diskHealthWrapper provides either a io.Reader or io.Writer
// that updates status of the provided tracker.
// Use through diskHealthReader or diskHealthWriter.
type diskHealthWrapper struct {
	tracker *healthDiskCtxValue
	r       io.Reader
	w       io.Writer
}

func (d *diskHealthWrapper) Read(p []byte) (int, error) {
	if d.r == nil {

    @Test
    void testConstructorAndGetters() {
        // Create a new instance with some test data
        short length = 10;
        short maxLength = 20;
        int pointer = 100;
        PacUnicodeString pacString = new PacUnicodeString(length, maxLength, pointer);

        // Verify that the object was created
        assertNotNull(pacString, "The PacUnicodeString object should not be null.");