writePos.row++;
    }

    @Override
    protected void doLineText(final CharSequence text) {
        if (text.length() == 0) {
            return;
        }

        ansiExecutor.writeAt(writePos, new Action<AnsiContext>() {
            @Override
            public void execute(AnsiContext ansi) {
                ansi.withStyle(getStyle(), new Action<AnsiContext>() {
                    @Override

        int startRow = writePos.row
        String text = "A" * TERMINAL_WIDTH +
            "B" * TERMINAL_WIDTH +
            "C" * TERMINAL_WIDTH +
            "D" * 3

        when:
        ansiExecutor.writeAt(writePos) {
            it.a(text)
        }

        then:
        writeCursor == Cursor.at(0, text.length())
        writePos == writeCursor
        interaction { expectLineWrapCallback(startRow, text.length()) }

	defer func() {
		if err != nil {
			if _, err := f.WriteAt(old, 0); err == nil {
				f.Truncate(int64(len(old)))
			}
		}
	}()

	if len(new) >= len(old) {
		if _, err := f.WriteAt(new[:len(old)], 0); err != nil {
			return err
		}
	} else {
		if _, err := f.WriteAt(new, 0); err != nil {
			return err
		}

	if _, err := r.f.Seek(r.offset+offset, 0); err != nil {
		return err
	}
	return binary.Read(r.f, r.order, data)
}

func (r loadCmdReader) WriteAt(offset int64, data interface{}) error {
	if _, err := r.f.Seek(r.offset+offset, 0); err != nil {
		return err
	}
	return binary.Write(r.f, r.order, data)
}

// machoCombineDwarf merges dwarf info generated by dsymutil into a macho executable.
//

// license that can be found in the LICENSE file.

package net

import "syscall"

func setKeepAlive(fd *netFD, keepalive bool) error {
	if keepalive {
		_, e := fd.ctl.WriteAt([]byte("keepalive"), 0)
		return e
	}
	return nil
}

func setLinger(fd *netFD, sec int) error {
	return syscall.EPLAN9

}

// WriterTo is the interface that wraps the WriteTo method.
//
// WriteTo writes data to w until there's no more data to write or
// when an error occurs. The return value n is the number of bytes
// written. Any error encountered during the write is also returned.
//
// The Copy function uses WriterTo if available.
type WriterTo interface {
	WriteTo(w Writer) (n int64, err error)
}

 * limitations under the License.
 */

package org.gradle.internal.logging.console;

import org.gradle.api.Action;

public interface AnsiExecutor {
    void write(Action<? super AnsiContext> action);
    void writeAt(Cursor writePos, Action<? super AnsiContext> action);

}

// Set keep alive period.
func setKeepAliveIdle(fd *netFD, d time.Duration) error {
	if d < 0 {
		return nil
	}

	cmd := "keepalive " + itoa.Itoa(int(d/time.Millisecond))
	_, e := fd.ctl.WriteAt([]byte(cmd), 0)
	return e
}

func setKeepAliveInterval(_ *netFD, d time.Duration) error {
	if d < 0 {
		return nil
	}
	return syscall.EPLAN9
}

func setKeepAliveCount(_ *netFD, n int) error {

        this.listener = listener;
    }

    @Override
    public void write(Action<? super AnsiContext> action) {
        Ansi ansi = factory.create();
        action.execute(new AnsiContextImpl(ansi, colorMap, writeCursor));
        write(ansi);
    }

    @Override
    public void writeAt(Cursor writePos, Action<? super AnsiContext> action) {
        Ansi ansi = factory.create();

			i := bytes.Index(buf[start:tiny+n], idBytes)
			if i < 0 {
				break
			}
			matches = append(matches, offset+int64(start+i-tiny))
			h.Write(buf[start : start+i])
			h.Write(zeros)
			start += i + len(id)
		}
		if n < bufSize {
			// Did not fill buffer, must be at end of file.
			h.Write(buf[start : tiny+n])
			break
		}

		// Process all but final tiny bytes of buf (bufSize = len(buf)-tiny).