'''

        expect:
        fails 'merge'
// Expected behavior:
//        when:
//        run 'merge'
//
//        then:
//        outputContains 'Transforming p1.zip'
//        outputContains 'Transforming p2.zip'
//        result.assertTasksExecuted ':p1:produce', ':p1:zip', ':p2:produce', ':p2:zip', ':merge'
//        file('merge.txt').text == 'p1.zip,p2.zip'
    }

 * for equality with the argument passed to {@code leaveDynamicCall}.
 * <p>
 * The implementations should be thread-safe and should support tracking the context in multiple threads.
 */
// TODO: consider transforming this to a more generic tool for tracking the events
//       of entering and leaving some generic context (marked with a key?)
@ServiceScope(Scope.CrossBuildSession.class)
public interface DynamicCallContextTracker {
    /**

                }
            }
        """

        when:
        run(":app:toBeFinalized", "withDependency")

        def lib1Message = "Transforming lib1.jar with MakeGreen"
        def lib2Message = "Transforming lib2.jar with MakeGreen"

        then:
        if (!GradleContextualExecuter.configCache) {

                }
        }

    override val visibility: Visibility
        get() = withValidityAssertion {
            // TODO: We should use resolvedStatus, because it can be altered by status-transforming compiler plugins. See KT-58572
            when (val possiblyRawVisibility = firSymbol.fir.visibility) {
                Visibilities.Unknown -> if (firSymbol.fir.isLocal) Visibilities.Local else Visibilities.Public

	// It does not include the time incurred in admission, or validation.
	StorageTracker DurationTracker

	// TransformTracker tracks the latency incurred in transforming the
	// response object(s) returned from the underlying storage layer.
	// This includes transforming the object to user's desired form
	// (ie. as Table), and also setting appropriate API level fields.
	// This does not include the latency incurred in serialization

absl::StatusOr<std::optional<tensorflow::SaverDef>> CreateSaverDef(
    const std::vector<std::string>& control_ret_node_names,
    const tensorflow::GraphDef& graph_def);

// Adds passes for transforming the MLIR module op so that it can be exported
// back to GraphDef. Roughly, this consists of:
//   1) Inserting the @main function, which will become the main Graph.
//   2) Duplicating shape-determining constants.

      /*result=*/"success");

  return absl::OkStatus();
}

mlir::PassPipelineRegistration<> replicated_clustering_bridge_v2(
    "tf-replicated-clustering-bridge-v2",
    "Run all the passes involved in transforming a TensorFlow 2 graph before "
    "execution so that it is suitable for targeting devices.",
    CreateReplicatedClusteringPipelineV2);

}  // namespace v2
}  // namespace tf2xla

                @InputArtifact
                abstract Provider<FileSystemLocation> getInputArtifact()

                @Override
                void transform(TransformOutputs outputs) {
                    println "Transforming printed to System.out"
                    outputs.file(inputArtifact)
                }
            }
        """
        file('src/main/java/artifact/transform/sample/App.java') << """

	// Find all systemstack calls and record their targets. In
	// general, flow analysis can't see into systemstack, but it's
	// important to handle it for this check, so we model it
	// directly. This has to happen before transforming closures in walk since
	// it's a lot harder to work out the argument after.
	for _, n := range typecheck.Target.Funcs {
		c.curfn = n
		if c.curfn.ABIWrapper() {
			// We only want "real" calls to these

  // canonicalize/optimizer.
  static mlir::PassPipelineRegistration<StandardPipelineOptions> pipeline(
      "tf-standard-pipeline",
      "Run all the passes involved in transforming/optimizing the graph after "
      "importing into MLIR, without any target specialization.",
      CreateTFStandardPipeline);
}

}  // namespace TF