// restartProcess starts a new process passing it the active fd's. It
// doesn't fork, but starts a new process using the same environment and
// arguments as when it was originally started. This allows for a newly
// deployed binary to be started. It returns the pid of the newly started
// process when successful.
func restartProcess() error {
	if runtime.GOOS == globalWindowsOSName {
		cmd := exec.Command(os.Args[0], os.Args[1:]...)

 */

package org.gradle.api.tasks.testing.logging;

/**
 * Test events that can be logged.
 */
public enum TestLogEvent {
    /**
     * A test has started. This event gets fired both for atomic and composite tests.
     */
    STARTED,

    /**
     * A test has completed successfully. This event gets fired both for atomic and composite tests.
     */
    PASSED,

    /**

        _ * buildStartEvent.getEventTime() >> 999
        _ * buildStartEvent.getDisplayName() >> 'build started'
        _ * buildStartEvent.getDescriptor() >> buildDescriptor

        def taskStartEvent = Mock(InternalOperationStartedProgressEvent)
        _ * taskStartEvent.getEventTime() >> 1001
        _ * taskStartEvent.getDisplayName() >> 'task started'
        _ * taskStartEvent.getDescriptor() >> taskDescriptor

     */
    GradleHandle abort();

    /**
     * Cancel a build that was started as a cancellable build by closing stdin.  Does not block until the build has finished.
     */
    GradleHandle cancel();

    /**
     * Cancel a build that was started as a cancellable build by sending EOT (ctrl-d).  Does not block until the build has finished.
     */
    GradleHandle cancelWithEOT();

 */
@UsedByScanPlugin("test-distribution, test-retry")
public interface TestResultProcessor {
    /**
     * Notifies this processor that a test has started execution.
     */
    @UsedByScanPlugin("test-distribution")
    void started(TestDescriptorInternal test, TestStartEvent event);

    /**
     * Notifies this processor that a test has completed execution.
     */
    @UsedByScanPlugin("test-distribution")

echo Usage: service.bat install^|remove^|start^|stop^|manager [SERVICE_ID]
goto:eof

:doStart
"%EXECUTABLE%" //ES//%SERVICE_ID% %LOG_OPTS%
if not errorlevel 1 goto started
echo Failed starting '%SERVICE_ID%' service
goto:eof
:started
echo The service '%SERVICE_ID%' has been started
goto:eof

:doStop
"%EXECUTABLE%" //SS//%SERVICE_ID% %LOG_OPTS%
if not errorlevel 1 goto stopped
echo Failed stopping '%SERVICE_ID%' service
goto:eof

		return true
	}

	if c.Started != nil && *c.Started {
		// Stop probing for startup once container has started.
		// we keep it running to make sure it will work for restarted container.
		if w.probeType == startup {
			return true
		}
	} else {
		// Disable other probes until container has started.
		if w.probeType != startup {
			return true
		}
	}

        this.testExecuter = testExecuter;
        this.delegate = delegate;
    }

    @Override
    public void started(TestDescriptorInternal testDescriptor, TestStartEvent startEvent) {
        delegate.started(testDescriptor, startEvent);
    }

    @Override
    public void completed(TestDescriptorInternal testDescriptor, TestResult testResult, TestCompleteEvent completeEvent) {

        then:
        failure.assertOutputContains("Hello")
        problems.assertFailureHasProblems(failure) {
            withProblem("Plugin 'test-convention-plugin': external process started")
        }

        where:
        snippetsFactory             | file
        exec().groovy               | "buildSrc/src/main/groovy/test-convention-plugin.gradle"

				return
			}
		case "User":
			z.User, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "User")
				return
			}
		case "Started":
			z.Started, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "Started")
				return
			}
		case "Replicate":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Replicate")
					return