}
        }
      }
    });
  });
  return success();
}

// Legalize StableHLO portion of program to VHLO, leaves TFL untouched
LogicalResult ApplyStablehloToVhloPatterns(ModuleOp module,
                                           bool is_func_legal) {
  MLIRContext *context = module.getContext();
  ConversionTarget target(*context);

  "tf_saved_model.asset"() {filename = "assets/mydata.txt", sym_name = "__tf_saved_model_asset0_mydata.txt"} : () -> ()
// Session initializer ops and asset ops untouched.
// CHECK: "tf_saved_model.session_initializer"() <{initializers = [@NoOp]}> : () -> ()
// CHECK: "tf_saved_model.asset"() <{filename = "assets/mydata.txt", sym_name = "__tf_saved_model_asset0_mydata.txt"}> : () -> ()

// Check that the initializers attribute is untouched.
// CHECK: "tf_saved_model.session_initializer"()
// CHECK-SAME: initializers = [@NoOp]

  func.func @NoOp()
    attributes {tf_saved_model.exported_names = ["__tf_saved_model_session_initializer_NoOp"], tf_saved_model.initializer_type = "init_op"} {
    return
  }
// The initializer function is untouched when the main function is empty.
// CHECK: func.func @NoOp

				rt.runner.SetAdditionalFlags(rt.setAdditionalFlags)
			}

			rt.runner.BindToCommand(cmd)

			// in case of no phases, checks that cmd is untouched
			if len(rt.runner.Phases) == 0 {
				if cmd.Long != "" {
					t.Error("cmd.Long is set while it should be leaved untouched\n")
				}

				if cmd.Flags().Lookup("skip-phases") != nil {
					t.Error("cmd has skip-phases flag while it should not\n")
				}

        createMetadataFile {
            addChecksum("org:foo:1.0", "md5", "abc")
            addChecksum("org:foo:1.0", "sha1", "1234")
            addChecksum("org:bar:1.0", "sha1", "untouched")
            trust("dummy", "artifact")
            trust("other", "artifact", "with", "file.jar", true)
        }

        given:
        javaLibrary()
        def foo = uncheckedModule("org", "foo")

// if 'x' and 'z' happen to share the same underlying storage.
// The overhead of the checking and branching is visible when 'z' are small (~5%),
// so set a threshold of 32, and remain the small-sized part entirely untouched.
TEXT ·addVW(SB),NOSPLIT,$0
	MOVD	z+0(FP), R3
	MOVD	z_len+8(FP), R0
	MOVD	x+24(FP), R1
	MOVD	y+48(FP), R2
	CMP	$32, R0
	BGE	large		// large-sized 'z' and 'x'
	CBZ	R0, len0	// the length of z is 0

        content.assertDoesNotExist()
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "recreates target directory when symlink is found, leaving linked content untouched"() {
        def linked = tmpDir.createDir("linked")
        def content = linked.createFile("content.txt")
        def target = tmpDir.file("target").tap { Files.createSymbolicLink(it.toPath(), linked.toPath()) }

// CHECK-DAG: %[[CST_0:.*]] = "tf.Const"
// CHECK-SAME: dense<1>
// Check that there are no extra "tf.Const"s existing in this function.
// CHECK-NOT: "tf.Const"

// Check that the usages of %[[CST]] and %[[CST_0]] are untouched.
// CHECK: %[[ADD:.*]] = "tf.AddV2"(%[[CST]], %[[CST_0]])
// CHECK: "tf.Max"({{.*}}, %[[ADD]])

// -----

// CHECK-LABEL: @recursively_duplicate_constants

----

Your logger can implement any of the listener interfaces listed below.
When you register a logger, only the logging for the interfaces it implements is replaced.
Logging for the other interfaces is left untouched.
You can find out more about the listener interfaces in <<build_lifecycle.adoc#sec:build_phases,Build lifecycle events>>.

		return nil, fmt.Errorf("error marshalling json patch: %v", err)
	}
	return versionBytes, nil
}

// MergeResizeConditionOnPVC updates pvc with requested resize conditions
// leaving other conditions untouched.
func MergeResizeConditionOnPVC(
	pvc *v1.PersistentVolumeClaim,
	resizeConditions []v1.PersistentVolumeClaimCondition) *v1.PersistentVolumeClaim {