import javax.annotation.Nullable;

@SuppressWarnings("deprecation")
public class LogEvent extends RenderableOutputEvent implements org.gradle.internal.logging.events.operations.LogEventBuildOperationProgressDetails {
    private final String message;
    private final Throwable throwable;

    public LogEvent(long timestamp, String category, LogLevel logLevel, String message, @Nullable Throwable throwable) {

    private final StyledTextOutput output = Mock()

    def renderWritesMessageToTextOutput() {
        given:
        def logEvent = new LogEvent(TIMESTAMP, CATEGORY, LogLevel.INFO, MESSAGE, null)

        when:
        logEvent.render(output)

        then:
        1 * output.text(MESSAGE)
        1 * output.println()
        TIMESTAMP * output._
    }

        given:
        def logEvent = Mock(LogEvent)
        def protocol = Mock(WorkerLoggingProtocol)

        when:
        listener.onOutput(logEvent)

        then:
        thrown(IllegalStateException)

        when:
        listener.setWorkerLoggingProtocol(protocol)
        listener.onOutput(logEvent)

        then:
        1 * protocol.sendOutputEvent(logEvent)

        and:

import org.gradle.api.logging.LogLevel;
import org.gradle.internal.logging.events.LogEvent;
import org.gradle.internal.operations.OperationIdentifier;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

public class LogEventSerializer implements Serializer<LogEvent> {
    private final Serializer<Throwable> throwableSerializer;

  override fun callStart(call: Call) = logEvent(CallStart(System.nanoTime(), call))

  override fun requestHeadersStart(call: Call) = logEvent(RequestHeadersStart(System.nanoTime(), call))

  override fun requestHeadersEnd(
    call: Call,
    request: Request,
  ) = logEvent(RequestHeadersEnd(System.nanoTime(), call, request.headers.byteCount()))

  override fun requestBodyStart(call: Call) = logEvent(RequestBodyStart(System.nanoTime(), call))

        LogEvent logEvent = event as LogEvent
        events.add(logEvent)
    }

        new GregorianCalendar(2012, Calendar.JUNE, 11, 10, 0, 0)
    }

    LogEvent event(String text) {
        return new LogEvent(tenAm, 'category', LogLevel.INFO, text, null)
    }

    LogEvent event(String text, LogLevel logLevel) {
        return new LogEvent(tenAm, 'category', logLevel, text, null)
    }

    LogEvent event(String text, LogLevel logLevel, long buildOperationId) {

    }

    def "can serialize LogEvent messages with failure and operation id"() {
        when:
        def event = new LogEvent(TIMESTAMP, CATEGORY, LogLevel.LIFECYCLE, MESSAGE, new RuntimeException(), new OperationIdentifier(42L))
        def result = serialize(event, serializer)

        then:
        result instanceof LogEvent
        result.timestamp == TIMESTAMP
        result.category == CATEGORY

        createLogger(LogLevel.INFO)

        when:
        logger.logEvent(rootDescriptor, TestLogEvent.STARTED)

        then:
        textOutputFactory.toString() == "{TestEventLogger}{INFO}${sep}Test Run STARTED${sep}"
    }

    def "log Gradle worker event"() {
        createLogger(LogLevel.INFO)

        when:
        logger.logEvent(workerDescriptor, TestLogEvent.STARTED)

        then:

    }

    void reset() {
        writer
    }

    @Override
    synchronized void onOutput(OutputEvent event) {
        if(event instanceof LogEvent){
            LogEvent logEvent = event as LogEvent
            writer.append("[")
            writer.append(logEvent.toString())
            writer.append("]")
        }
        if(event instanceof StyledTextOutputEvent){