}

    @Issue("https://github.com/gradle/gradle/issues/20398")
    def "falls back to full file hash when abi extraction fails for a regular file"() {
        def apiClassExtractor = Mock(ApiClassExtractor)

        def resourceHasher = AbiExtractingClasspathResourceHasher.withFallback(apiClassExtractor)

            on { getByName(eq("alice"), any<Action<DomainObject>>()) } doReturn alice
            on { create(eq("bob"), any<Action<DomainObject>>()) } doReturn bob
        }

        // regular syntax
        container.getByName("alice") {
            foo = "alice-foo"
        }
        container.create("bob") {
            foo = "bob-foo"
        }
        container.maybeCreate("john")

    /**
     * Called before visiting the contents of a directory.
     */
    public void enterDirectory(DirectorySnapshot directorySnapshot, boolean isRoot) {}

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */

#include "absl/strings/string_view.h"
#include "tensorflow/core/protobuf/fingerprint.pb.h"

namespace tensorflow::saved_model::fingerprinting {

// Creates a FingerprintDef proto from a SavedModel (regular or chunked) and the
// checkpoint meta file (.index) in `export_dir`.
absl::StatusOr<FingerprintDef> CreateFingerprintDef(
    absl::string_view export_dir);

#include "tensorflow/core/protobuf/meta_graph.pb.h"

namespace mlir::quant {

// Converts arguments of the @main function that are bound to
// `tf_saved_model::AssetOp`s into regular tensor args. Returns `AsestFileDef`s
// that associates the arg with the asset.
//
// In detail, this function performs the following:
// * Replaces "tf_saved_model.bound_input" attributes to

## How to enable Fan-Out Uploads ?

        self,
        func: Annotated[
            Callable[P, Any],
            Doc(
                """
                The function to call after the response is sent.

                It can be a regular `def` function or an `async def` function.
                """
            ),
        ],
        *args: P.args,
        **kwargs: P.kwargs,
    ) -> None:
        """

import (
	"fmt"
	"runtime"
	"strings"
	"sync"
)

// On the disk, and upstream, stack counters look like sets of
// regular counters with names that include newlines.

// a StackCounter is the in-memory knowledge about a stack counter.
// StackCounters are more expensive to use than regular Counters,
// requiring, at a minimum, a call to runtime.Callers.
type StackCounter struct {
	name  string
	depth int
	file  *file

        outputContains("project name = root")
        outputContains("project name = a")
        outputContains("project name = b")

        where:
        functionType | modifier  | owner
        "regular"    | ""        | "new Helper()"
        "static"     | "static " | "Helper"
    }

    @ToBeImplemented
    def "lifecycle actions in Kotlin DSL allow using top-level build script function"() {

//
// Specifically:
//
// 1. `new(T)`, `make([]T)`, `append([]T, ...)` and implicit heap
// allocation of T are disallowed. (Though implicit allocations are
// disallowed in the runtime anyway.)
//
// 2. A pointer to a regular type (other than `unsafe.Pointer`) cannot be
// converted to a pointer to a not-in-heap type, even if they have the
// same underlying type.
//