* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.process.internal.worker;

import org.gradle.internal.logging.events.LogEvent;
import org.gradle.internal.logging.events.OutputEventListener;
import org.gradle.internal.logging.events.StyledTextOutputEvent;
import org.gradle.process.internal.worker.child.WorkerLoggingProtocol;

    route: Route,
    call: Call,
  ) {
    logEvent(ConnectionEvent.ConnectEnd(System.nanoTime(), connection, route, call))
  }

  override fun connectionClosed(connection: Connection) = logEvent(ConnectionEvent.ConnectionClosed(System.nanoTime(), connection))

  override fun connectionAcquired(
    connection: Connection,
    call: Call,
  ) {

        LogEvent logEvent = new LogEvent(clock.getCurrentTime(), name, logLevel, message, throwable, operationIdentifier);
        OutputEventListener outputEventListener = context.getOutputEventListener();
        try {
            outputEventListener.onOutput(logEvent);
        } catch (Throwable e) {
            // fall back to standard out

        }

        then:
        0 * stdoutChain.onOutput(_)
        1 * stderrChain.onOutput(_) >> { args -> assert args[0].logLevel == LogLevel.ERROR }
    }

    LogEvent event(level) {
        LogEvent event = Stub(LogEvent)
        event.logLevel >> level
        return event
    }

                && isLoggedEventType(TestLogEvent.STANDARD_OUT)) {
            logEvent(descriptor, TestLogEvent.STANDARD_OUT, TextUtil.indent(outputEvent.getMessage(), INDENT) + "\n");
        } else if (outputEvent.getDestination() == TestOutputEvent.Destination.StdErr
                && isLoggedEventType(TestLogEvent.STANDARD_ERROR)) {
            logEvent(descriptor, TestLogEvent.STANDARD_ERROR, TextUtil.indent(outputEvent.getMessage(), INDENT) + "\n");

    private final String[] loggerNames;

    public ErrorToWarnRewritePolicy(final String[] loggerNames) {
        this.loggerNames = loggerNames;
    }

    @Override
    public LogEvent rewrite(final LogEvent event) {
        final String loggerName = event.getLoggerName();
        if (loggerName == null) {
            return event;
        }
        for (final String name : loggerNames) {

        }

        where:
        eventType             | eventWithBuildOperationId                                              | eventWithFallbackBuildOperationId
        LogEvent              | new LogEvent(0, 'c', LogLevel.INFO, 'm', null, testOperationId)        | new LogEvent(0, 'c', LogLevel.INFO, 'm', null, null)

                return (OperationGroup) state;
            }
            current = state.parentProgressOp;
        }
        return null;
    }

    private static LogEvent spacerLine(long timestamp, String category) {
        return new LogEvent(timestamp, category, LogLevel.LIFECYCLE, "", null);
    }

    private static class OperationState {
        final @Nullable
        OperationIdentifier parentProgressOp;

            throw new IllegalStateException(getClass().getSimpleName() + " received an output event before the worker logging protocol object was set.");
        }

        if (event instanceof LogEvent) {
            loggingProtocol.sendOutputEvent((LogEvent) event);
        } else if (event instanceof StyledTextOutputEvent) {
            loggingProtocol.sendOutputEvent((StyledTextOutputEvent) event);
        }
    }

 */

package org.gradle.internal.logging.console

import org.gradle.api.logging.LogLevel
import org.gradle.internal.logging.OutputSpecification
import org.gradle.internal.logging.events.LogEvent
import org.gradle.internal.logging.events.LogLevelChangeEvent
import org.gradle.internal.logging.events.OutputEventListener
import spock.lang.Subject

@Subject(BuildLogLevelFilterRenderer)