* limitations under the License.
 */
package org.gradle.tooling;

/**
 * Some information about a piece of work of a long running operation.
 * @since 1.0-milestone-3
 */
public interface ProgressEvent {
    /**
     * A description of the current piece of work.
     *
     * @return The description.
     * @since 1.0-milestone-3
     */
    String getDescription();

import org.gradle.internal.logging.events.ProgressEvent;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

public class ProgressEventSerializer implements Serializer<ProgressEvent> {
    @Override
    public void write(Encoder encoder, ProgressEvent event) throws Exception {

        def result = serialize(event, serializer)

        then:
        result instanceof ProgressEvent
        result.progressOperationId == OPERATION_ID
        result.status == "status"
        result.failing
    }

    def "can serialize ProgressEvent messages with empty fields"() {
        given:
        def event = new ProgressEvent(OPERATION_ID, "", false)

        when:
        def result = serialize(event, serializer)

                broadcaster.progress(buildOperation.id, progressEvent)
            }

            @Override
            void finished(BuildOperationDescriptor buildOperation, OperationFinishEvent finishEvent) {
                super.finished(buildOperation, finishEvent)
                broadcaster.progress(buildOperation.id, progressEvent)
            }
        })
        manager.addListener(recordingListener("3"))

        1 * consumer.started(clientStartEvent)
        0 * _

        when:
        generator.progress(operationId, progressEvent)

        then:
        1 * mapper2.createProgressEvent(clientDescriptor, progressEvent) >> mappedProgressEvent
        1 * consumer.progress(mappedProgressEvent)
        0 * _

        when:
        generator.finished(operation, finishEvent)

            DefaultTestOutputResult result = new DefaultTestOutputResult(progressEvent.getTime(), progressEvent.getTime(), destination, progress.getOutput().getMessage());
            eventConsumer.progress(new DefaultTestOutputEvent(progressEvent.getTime(), descriptor, result));
        }
    }

    private static int getDestination(TestOutputEvent.Destination destination) {

        validatingListener.receivedCustomTestTaskProgressEvents()
    }

    class ValidatingProgressEventListener implements ProgressListener {

        ProgressEvent suiteEvent = null
        ProgressEvent testEvent = null

        @Override
        void statusChanged(ProgressEvent event) {
            if (event.descriptor.displayName == "Test suite 'MyCustomTestRoot'") {
                suiteEvent = event

                }
            } else if (event instanceof ProgressEvent) {
                ProgressEvent progressEvent = (ProgressEvent) event;
                if (!operationIdsToSkip.contains(progressEvent.getProgressOperationId())) {
                    operations.progress(progressEvent.getStatus(), progressEvent.getProgressOperationId());
                }
            }
        }
        queue.clear();

                invokeListener(event);
            }
        } else if (event instanceof ProgressEvent) {
            ProgressEvent progressEvent = (ProgressEvent) event;
            if (forwarded.contains(progressEvent.getProgressOperationId())) {
                invokeListener(event);
            }
        } else if (event instanceof RenderableOutputEvent) {

    final String detailsClassName;

    SerializedOperationProgress(OperationIdentifier id, OperationProgressEvent progressEvent) {
        this.id = id.getId();
        this.time = progressEvent.getTime();
        this.details = toSerializableModel(progressEvent.getDetails());
        this.detailsClassName = details == null ? null : progressEvent.getDetails().getClass().getName();
    }

    SerializedOperationProgress(Map<String, ?> map) {