def "uniqueRecentDaemonStopEvents() handles stop events with null status and reason"() {
        expect:
        DaemonStopEvents.uniqueRecentDaemonStopEvents([gracefulStop2, nullStop1, gracefulStop1]) == [gracefulStop2, gracefulStop1]
        DaemonStopEvents.uniqueRecentDaemonStopEvents([nullStop1, nullStop1]) == [nullStop1]
    }

    def "uniqueRecentDaemonStopEvents() handles empty lists"() {
        expect:

     */
    GradleInternal gradleInstanceForProject(ProjectInternal referrerProject, GradleInternal gradle);

    /**
     * Provides an implementation of a tracker that handles the usages of TaskDependency API in the context
     * of the current project. The tracker checks that the usages for possible violation of cross-project model access restriction.

        "current/dir/child.txt"    | "child.txt"
        "current/subdir"           | "../subdir"
        "current/subdir/child.txt" | "../subdir/child.txt"
    }

    def "handles mixed paths inside of root"() {
        when:
        def file = new File(rootDir, filePath)
        def current = new File(rootDir, "current/dir")

        then:
        transform(current, file) == relativePath

import javax.tools.DiagnosticListener;
import javax.tools.JavaCompiler;
import java.io.Closeable;
import java.nio.charset.Charset;
import java.util.Locale;

/**
 * Cleans up resources (e.g. file handles) after compilation has finished.
 */
class ResourceCleaningCompilationTask implements JavaCompiler.CompilationTask {
    private final JavaCompiler.CompilationTask delegate;
    private final Closeable fileManager;

		klog.FlushAndExit(klog.ExitFlushTimeout, 1)
	}
}

// OnNodeDelete is a handler for Node deletes.
func (n *NodePodCIDRHandler) OnNodeDelete(node *v1.Node) {
	n.logger.Error(nil, "Current Node is being deleted", "node", klog.KObj(node))
}

// OnNodeSynced is a handler for Node syncs.
func (n *NodePodCIDRHandler) OnNodeSynced() {}

// NodeEligibleHandler handles the life cycle of the Node's eligibility, as

// TensorFlow Resource Handles.
//===----------------------------------------------------------------------===//

inline bool IsResourceHandleAnonymous(StringRef name) {
  return name == ::tensorflow::ResourceHandle::ANONYMOUS_NAME;
}

// Helper struct representing an identifier for a resource handle. For resource
// handles created explicitly and shared across resource allocator ops,

      /*desc=*/[{Returns resource handle values and the unique ids associated with
                 the resource handles for this op. The handles should be created
                 for only the resource tensors in the results of the op. If a
                 resource handle is reused, then an existing id will be
                 returned. The order of the resource handles in the returned

        then:
        def ex = thrown(StaleDaemonAddressException)
        ex.cause == failure
        1 * staleAddressDetector.maybeStaleAddress(failure) >> true
        0 * staleAddressDetector._
    }

    def "handles failed dispatch"() {
        def failure = new FooException()
        def message = Stub(Message)

        given:
        delegate.receive() >> Stub(Message)
        delegate.dispatch(message) >> { throw failure }

                    }
                }
            }
        """

        expect:
        succeeds "compileJava"
    }

    def "handles -sourcepath being specified"() {
        goodCode()
        buildFile << """
            tasks.withType(JavaCompile) {
                options.sourcepath = project.layout.files()
            }
        """

    into 'build'
    from configurations.compile
}
"""

        when: "Version 1.1 is published"
        def module = ivyHttpRepo.module("group", "projectA", "1.1").publish()

        and: "Server handles requests"
        module.ivy.expectGet()
        module.jar.expectGet()

        and: "We request 1.1 (changing)"
        run 'retrieve'

        then: "Version 1.1 jar is downloaded"