* Implementations must take care to be threadsafe.
 *
 * Related signals are guaranteed to be serialized.
 * That is, a listener will not concurrently be notified of the same operation starting and finishing.
 *
 * @since 3.5
 */
@EventScope(Global.class)
public interface BuildOperationListener {

    void started(BuildOperationDescriptor buildOperation, OperationStartEvent startEvent);

import java.util.concurrent.locks.ReentrantLock;

class DefaultBuildOperationQueue<T extends BuildOperation> implements BuildOperationQueue<T> {
    private enum QueueState {
        Working, Finishing, Cancelled, Done
    }

    private final boolean allowAccessToProjectState;
    private final WorkerLeaseService workerLeases;
    private final Executor executor;
    private final QueueWorker<T> queueWorker;

    exec.awaitTermination(100, MILLISECONDS);
  }

  /**
   * Tests that all listeners complete, even if they were added before or after the future was
   * finishing. Also acts as a concurrency test to make sure the locking is done correctly when a
   * future is finishing so that no listeners can be lost.
   */
  public void testAllListenersCompleteSuccessfully()
      throws InterruptedException, ExecutionException {

    public final static String STARTED_EXECUTING_COMMAND = "Starting executing command: ";
    public final static String FINISHED_EXECUTING_COMMAND = "Finishing executing command: ";
    public final static String STARTED_BUILD = "The daemon has started executing the build.";
    public final static String FINISHED_BUILD = "The daemon has finished executing the build.";

 * limitations under the License.
 */

package org.gradle.internal.scan.eob;

import javax.annotation.Nullable;

/**
 * Used by the scan plugin to register a listener to be notified about the build finishing.
 */
public interface BuildScanEndOfBuildNotifier {

    interface BuildResult {
        @Nullable
        Throwable getFailure();
    }

    interface BuildScanResult {

    }

     *
     * @param failures The failures to report to the build finished hooks.
     * @return The exception to throw, packages up the given failures plus any failures finishing the build.
     */
    @Nullable
    RuntimeException finishBuildTree(List<Throwable> failures);

    exec.awaitTermination(100, MILLISECONDS);
  }

  /**
   * Tests that all listeners complete, even if they were added before or after the future was
   * finishing. Also acts as a concurrency test to make sure the locking is done correctly when a
   * future is finishing so that no listeners can be lost.
   */
  public void testAllListenersCompleteSuccessfully()
      throws InterruptedException, ExecutionException {

                    logger.quiet 'Starting test: ' + descriptor.className + ' > ' + descriptor.name
                }
                afterTest { descriptor, result ->
                    logger.quiet 'Finishing test: ' + descriptor.className + ' > ' + descriptor.name
                }
            }
        """
        file(JAVA_TEST_FILE_PATH) << javaTestClass { '' }

        when:

     * The jobs will be complete before {@link GradleEnterprisePluginEndOfBuildListener#buildFinished(GradleEnterprisePluginEndOfBuildListener.BuildResult)} is called.
     * <p>
     * The job may be rejected if the build is already finishing and the executor is being shut down.
     * In such a case a {@link RejectedExecutionException} is thrown from {@link Executor#execute(Runnable)}.
     * <p>
     * The job should not throw exceptions.

  }

  /**
   * Subclasses must call this method after finishing character processing, in order to ensure that
   * any unterminated line in the buffer is passed to {@link #handleLine}.
   *
   * @throws IOException if an I/O error occurs
   */
  protected void finish() throws IOException {
    if (sawReturn || line.length() > 0) {
      finishLine(false);
    }
  }

  /**