this.file = file;
        bufferedOutputStream = new ResettableBufferedOutputStream(new RandomAccessFileOutputStream(file));
    }

    /**
     * Starts writing to the given offset. Can be beyond the current length of the file.
     */
    public DataOutputStream start(long offset) throws IOException {
        file.seek(offset);
        bufferedOutputStream.clear();

    /**
     * Starts a timeout for the given thread. The thread is interrupted if the given timeout is exceeded.
     * The returned {@link Timeout} object must be used to stop the timeout once the thread has completed
     * the work that this timeout was supposed to limit, otherwise it may be interrupted doing
     * some other work later.
     */

        WorkerProcess workerProcess = workerDaemonProcess.start();

        WorkerDaemonClient client = new WorkerDaemonClient(forkOptions, workerDaemonProcess, workerProcess, loggingManager.getLevel(), actionExecutionSpecFactory);

        LOG.info("Started Gradle worker daemon ({}) with fork options {}.", clock.getElapsed(), forkOptions);

        return client;
    }

    /**
     * Invoked when the code starts an external process. The command string with all argument is provided for reporting but its value may not be suitable to actually invoke the command because all
     * arguments are joined together (separated by space) and there is no escaping of special characters.
     *
     * @param command the command used to start the process (with arguments)

        then
            arg=$( cygpath --path --ignore --mixed "$arg" )
        fi
        # Roll the args list around exactly as many times as the number of
        # args, so each arg winds up back in the position where it started, but
        # possibly modified.
        #
        # NB: a `for` loop captures its iteration list before it begins, so
        # changing the positional parameters here affects neither the number of

            if (file.endsWith(".gradle.kts")) {
                withProblem("Settings file '${relativePath(file)}': external process started")
            } else {
                withProblem("Settings file '${relativePath(file)}': line 5: external process started")
            }
        }

        where:
        snippetsFactory             | file
        exec().groovy               | "included/settings.gradle"

 *
 * Implementations are thread safe and can be signalled concurrently.
 * However, a finished signal must not be emitted before the signal of the
 * corresponding started event has returned.
 *
 * Implementations may retain the notification values beyond the method that passed them.
 * Started notifications maybe held until a corresponding finished notification, and slightly after.

 * - If one segment starts with the other segment comparing case-insensitive, then the shorter segment is smaller.
 * - Finally, if both segments are the same ignoring case and have the same length, the case-sensitive comparison is used.
 *
 * For all methods operating on a list of paths, the paths must not start with a common segment.

 */

package org.gradle.internal.operations.notify;

import org.gradle.internal.scan.UsedByScanPlugin;

import javax.annotation.Nullable;

/**
 * A notification that a build operation has started.
 *
 * The methods of this interface are awkwardly prefixed to allow
 * internal types to implement this interface along with other internal interfaces
 * without risking method collision.
 *
 * @since 4.0
 */

        when:
        def stream = output.start(0)
        stream.writeInt(123)
        stream.writeByte(12)
        output.done()

        then:
        file.length() == 5
        file.seek(0)
        file.readInt() == 123
        file.readByte() == 12

        when:
        stream = output.start(5)
        stream.writeInt(321)
        output.done()

        then: