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"

        output(SWIFTC_OUTPUT_MAC_OS).component.version.with { [major, minor, micro] } == [4, 0, 2]
        output(SWIFTC_OUTPUT_LINUX).component.version.with { [major, minor, micro] } == [3, 1, 1]
    }

    def "handles output that cannot be parsed"() {
        def visitor = new TreeFormatter()

        expect:
        def result = output(out)
        !result.available

        when:
        result.explain(visitor)

	}

	return nil, collapseAggregateErrors(errors)
}

func (m FirstHitRESTMapper) Reset() {
	m.MultiRESTMapper.Reset()
}

// collapseAggregateErrors returns the minimal errors.  it handles empty as nil, handles one item in a list
// by returning the item, and collapses all NoMatchErrors to a single one (since they should all be the same)
func collapseAggregateErrors(errors []error) error {
	if len(errors) == 0 {
		return nil

	}
	cert := pem.EncodeToMemory(block)

	return cert, nil
}

// Check handles health check requests.
func (s *CAServer) Check(ctx context.Context, in *ghc.HealthCheckRequest) (*ghc.HealthCheckResponse, error) {
	return &ghc.HealthCheckResponse{
		Status: ghc.HealthCheckResponse_SERVING,
	}, nil
}

// Watch handles health check streams.

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

/**
 * A handler for an intermediate result obtained by a {@link BuildActionExecuter}.
 *
 * @param <T> The result type.
 * @since 4.8
 */
public interface IntermediateResultHandler<T> {

    /**
     * Handles successful completion of the action.
     *
     * @param result the result
     */
    void onComplete(T result);