}

  if (VLOG_IS_ON(2) || DEBUG_DATA_DUMPER()->ShouldDump(
                           module_name.str(), kDebugGroupBridgePhase2)) {
    // Print the whole module after each pass which requires disabling
    // multi-threading as well.
    module_op.getContext()->disableMultithreading();
    tf2xla.enableIRPrinting(
        std::make_unique<::tensorflow::DataDumperLoggerConfig>(

[[sub:disable_auto_provision]]
=== Disabling auto provisioning

In order to disable auto-provisioning, you can use the `org.gradle.java.installations.auto-download` Gradle property:

* Either start gradle using `-Porg.gradle.java.installations.auto-download=false`
* Or put `org.gradle.java.installations.auto-download=false` into a `gradle.properties` file.

[NOTE]
====

		return v.IsNil()
	}
	return false
}

// canCompare reports whether v1 and v2 are both the same kind, or one is nil.
// Called only when dealing with nillable types, or there's about to be an error.
func canCompare(v1, v2 reflect.Value) bool {
	k1 := v1.Kind()
	k2 := v2.Kind()
	if k1 == k2 {
		return true
	}
	// We know the type can be compared to nil.

  reached or started.

  All of these operations will produce their own unique errors in the absence of
  a coordinated offline strategy. In addition, efforts to unite these failing
  behaviors behind a consistent user interface is much, much more difficult if
  the system can't tell whether it has access to the network required by these
  operations.

        when:
        succeeds('customTask')

        then:
        result.assertTasksExecutedInOrder(':climbTask', ':customTask')
    }

    def "a build failure occurs when depending on a rule task with failing configuration"() {
        given:
        buildFile << """
        ${ruleBasedTasks()}

        class Rules extends RuleSource {
            @Mutate
            void addTasks(ModelMap<Task> tasks) {

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

package ld

import (
	"bufio"
	"cmd/internal/goobj"
	"cmd/internal/objabi"
	"cmd/internal/quoted"
	"cmd/internal/sys"
	"cmd/internal/telemetry"
	"cmd/link/internal/benchmark"

[[sec:complete_rewrite_of_eclipse_files]]
==== Disabling merging with a complete rewrite

			logger.V(5).Info("ResourceSlice delete", "slice", klog.KObj(slice))
			c.queue.Add(slice.DriverName)
		},
	})
	if err != nil {
		logger.Error(err, "Registering event handler on the ResourceSlice informer failed, disabling resource monitoring")
		return
	}

	// Start informer and wait for our cache to be populated.
	c.wg.Add(1)
	go func() {
		defer c.wg.Done()
		informer.Run(ctx.Done())
	}()

        1 * processor.completed(2, { it.resultType == null })
        0 * processor._
    }

    @Issue("GRADLE-3112")
    def "has no errors when dealing with an empty suite"() {
        setup:
        classProcessor = createProcessor([] as Set, [] as Set, ["*AnEmptyTestSuite"] as Set, [] as Set, [] as Set)

        //Run tests in AnEmptyTestSuite (e.g. no tests)

      }
    };
  }

  /**
   * Shuts down the given executor service gradually, first disabling new submissions and later, if
   * necessary, cancelling remaining tasks.
   *
   * <p>The method takes the following steps:
   *
   * <ol>
   *   <li>calls {@link ExecutorService#shutdown()}, disabling acceptance of new submitted tasks.
   *   <li>awaits executor service termination for half of the specified timeout.