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()) }

 * 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();

     */
    AnsiContext cursorAt(Cursor cursor);

    /**
     * @return a new context at the specified write position.
     */
    AnsiContext writeAt(Cursor writePos);

                // Does not need to be redrawn
                return;
            }

            int writtenTextLength = writePos.col;
            writePos.col = 0;
            redrawText(ansi.writeAt(writePos), writtenTextLength);

            writtenSpans = spans;
            previousWriteRow = absolutePositionRow;
        }
    }

    private void redrawText(AnsiContext ansi, int writtenTextLength) {

                int previousLength = entries.get(i + newLines).getWritePosition().col;
                if (currentLength < previousLength) {
                    ansi.writeAt(label.getWritePosition()).eraseForward();
                }
            }
        }

        if (isPreviouslyVisible || isVisible) {
            ansi.cursorAt(parkCursor());
        }

			return err
		}
		if cmd.Cmd == LC_UUID {
			var u uuidCmd
			if err := reader.ReadAt(0, &u); err != nil {
				return err
			}
			copy(u.Uuid[:], uuidFromGoBuildId(*flagBuildid))
			if err := reader.WriteAt(0, &u); err != nil {
				return err
			}
			break
		}
	}

	// We're done
	return nil

}

// Write encodes p using quoted-printable encoding and writes it to the
// underlying [io.Writer]. It limits line length to 76 characters. The encoded
// bytes are not necessarily flushed until the [Writer] is closed.
func (w *Writer) Write(p []byte) (n int, err error) {
	for i, b := range p {
		switch {
		// Simple writes are done in batch.
		case b >= '!' && b <= '~' && b != '=':
			continue