OpBuilder builder(first_if);
  builder.setInsertionPoint(if_op_segment.back().getOperation());

  auto new_if_op = builder.create<TF::IfRegionOp>(
      first_if.getLoc(), merged_return_types, first_if.getCond(),
      llvm::all_of(if_op_segment,
                   [&](TF::IfRegionOp op) { return op.getIsStateless(); }),
      first_if.get_thenFuncNameAttr(), first_if.get_elseFuncNameAttr());

    }

    def "keeps watching outermost hierarchy until there is no content left"() {
        def firstDir = file("first").createDir()
        def secondDir = file("second").createDir()
        def directoryWithinFirst = file("first/within").createDir()

        registerWatchableHierarchies([directoryWithinFirst, firstDir, secondDir])

        when:
        addSnapshotInWatchableHierarchy(secondDir)
        then:

            """
            package plugins
            """
        )


        val firstDir = existing(firstLocation)
        val secondDir = newDir(secondLocation)
        firstDir.copyRecursively(secondDir)

        val cachedTasks = listOf(
            ":extractPrecompiledScriptPluginPlugins",
            ":generateExternalPluginSpecBuilders",

func (m *UsernsManager) allocateOne(pod types.UID) (firstID uint32, length uint32, err error) {
	firstZero, found, err := m.used.AllocateNext()
	if err != nil {
		return 0, 0, err
	}
	if !found {
		return 0, 0, fmt.Errorf("could not find an empty slot to allocate a user namespace")
	}

	klog.V(5).InfoS("new pod user namespace allocation", "podUID", pod)

	firstID = uint32((firstZero + m.off) * userNsLength)

        def cacheDir = createDir("cache-dir")

        def firstDir = createDir("first-location")
        firstDir.file("settings.gradle") << """
            rootProject.name = "test"
            buildCache {
                local {
                    directory = file("../${cacheDir.name}")
                }
            }
        """
        firstDir.file("buildSrc/build.gradle") << """
            plugins {

    # bins[i + 1] = lower_bound + (i + 1) * bin_width
    # So hist_mids[i] = (lower_bound + bin_width / 2) + bin_width * i
    first_mid = self._lower_bound + self._bin_width / 2
    last_mid = first_mid + (self._num_bins - 1) * self._bin_width
    self._hist_mids = np.linspace(first_mid, last_mid, self._num_bins)

  def _get_dequantized_hist_mids_after_quantize(
      self, quant_min: float, quant_max: float
  ) -> np.ndarray:

      XlaComputation& computation) {
    SourceMgrDiagnosticHandler sourceMgrHandler(source_manager_, &context_);

    mlir::Operation& first_op = GetFirstOpFromMain();

    Tf2XlaRewriterTestPeer test_peer(&first_op);
    return test_peer.ImportXlaComputationIntoModule(computation);
  }

 protected:
  MLIRContext context_;
  OwningOpRef<ModuleOp> module_;

            plugins {
                id("base")
            }

            task wrongZip(type: Zip) {
                archiveBaseName = "wrong"
            }
            task firstZip(type: Zip) {
                archiveBaseName = "first"
            }

            configurations {
                consumable("blah") {
                    attributes {

        install.exec().out == helloWorldApp.frenchOutput
    }

    @ToBeFixedForConfigurationCache
    def "link order is stable across project directories for the same sources"() {
        def firstCopy = file("firstDir")
        def secondCopy = file("secondDir")
        [ firstCopy, secondCopy ].each { projectDir ->
            projectDir.file("settings.gradle").touch()
            def buildFile = projectDir.file("build.gradle")

		mappingLen     uint32
		maxPods        int
		success        bool
	}{
		{
			name:    "default",
			success: true,
		},
		{
			name:           "firstID not multiple",
			mappingFirstID: 65536 + 1,
		},
		{
			name:           "firstID is less than 65535",
			mappingFirstID: 1,
		},
		{
			name:           "mappingLen not multiple",
			mappingFirstID: 65536,
			mappingLen:     65536 + 1,
		},