id.getDisplayName() == "original -> current (foo)"
    }

    def "equals and hash code differentiate between same and different instances"() {
        def componentId = newComponentId("foo")

        when:
        def id = new TransformedComponentFileArtifactIdentifier(componentId, "a", "b")
        def same = new TransformedComponentFileArtifactIdentifier(componentId, "a", "b")

    }

    def "repositories have the same id when metadata sources and other configuration is the same"() {
        def repo = newRepo()
        def same = newRepo()
        def different = newRepo()

        given:
        repo.url = new URI("http://localhost")
        source(repo)
        same.url = new URI("http://localhost")
        source(same)
        different.url = new URI("http://localhost")

//CHECK: %0 = "vhlo.convolution_v1"(%arg0, %arg1) <{
//CHECK-SAME: batch_group_count = #vhlo.integer_v1<1 : i64>,
//CHECK-SAME: feature_group_count = #vhlo.integer_v1<32 : i64>,
//CHECK-SAME: input_batch_dimension = #vhlo.integer_v1<0 : i64>,
//CHECK-SAME: input_feature_dimension = #vhlo.integer_v1<3 : i64>,
//CHECK-SAME: input_spatial_dimensions = #vhlo.tensor_v1<dense<[1, 2]> : tensor<2xi64>>,
//CHECK-SAME: kernel_input_feature_dimension = #vhlo.integer_v1<2 : i64>,

Did you know?

  - [testing.T] is one doc link.
  - So is [testing.M].
  - So is [testing.B].
    This is the same list paragraph.

    There is [testing.PB] in this list item, too!
-- text --
Did you know?

  - testing.T is one doc link.

  - So is testing.M.

  - So is testing.B. This is the same list paragraph.

    There is testing.PB in this list item, too!
-- markdown --
Did you know?

# Tests different SignatureDef's with identical method_name string

# CHECK:      func {{@[a-zA-Z_0-9]+}}(
# CHECK-SAME:   {{.*}})
# CHECK-SAME: attributes {{.*}} tf_saved_model.exported_names = ["key"]

# CHECK:      func {{@[a-zA-Z_0-9]+}}(
# CHECK-SAME:   {{.*}})
# CHECK-SAME: attributes {{.*}} tf_saved_model.exported_names = ["key2"]


def Test():

  x = tf.constant(1.0, shape=(3, 3))

// CHECK-LABEL: func private @main_stream_{{[0-9]*}}
// CHECK-SAME: ([[ARG:%.*]]: tensor<i32>, [[FUTURE:%.*]]: !mlrt.future, [[CONTROL_PROMISE:%.*]]: !mlrt.promise)
// CHECK: [[HANDLE:%.*]] = "tf_mlrt.tf_await"([[FUTURE]])
// CHECK: "tf.AssignVariableOp"([[HANDLE]], [[ARG]])
// CHECK-NEXT: mlrt.promise_control [[CONTROL_PROMISE]]

// CHECK-LABEL: func private @main_stream_{{[0-9]*}}

[[concepts_repeatable_task_outputs]]
== Repeatable task outputs

Assume that you have a code generator task as part of your build.
When you have a fully up to date build and you clean and re-run the code generator task on the same code base it should generate _exactly the same output_, so anything that depends on that output will stay up-to-date.

On top of that, an async framework could run some sync code in a threadpool (using `asyncio.run_in_executor`), but belonging to the same request.

Dependency version alignment allows different modules belonging to the same logical group (a _platform_) to have identical versions in a dependency graph.

== Handling inconsistent module versions

Gradle supports aligning versions of modules which belong to the same "platform".
It is often preferable, for example, that the API and implementation modules of a component are using the same version.

  %cst_0 = "tf.Const"() {value = dense<0.500000e+00> : tensor<2xf32>} : () -> tensor<2xf32>
  %0 = "tf.Conv2D"(%arg0, %cst) {data_format = "NHWC", dilations = [1, 1, 2, 1], explicit_paddings = [], padding = "SAME", strides = [1, 1, 2, 1], use_cudnn_on_gpu = true} : (tensor<1x3x4x3xf32>, tensor<2x3x3x2xf32>) -> tensor<1x3x2x2xf32>
  %1 = "tf.AddV2"(%0, %cst_0) : (tensor<1x3x2x2xf32>, tensor<2xf32>) -> tensor<1x3x2x2xf32>