and: "multiple sub-projects"
        settingsFile << """
            include 'foo:foo'
            include 'bar:bar'
        """

        // Make the classpath of :foo differ from :bar's
        // thus causing :foo:foo and :bar:bar to have separate ClassLoaders.
        File someLib = file('lib/someLib.jar')
        jarWithClasses(someLib, SomeClass: 'class SomeClass {}')

        file("foo/build.gradle") << """

        file("settings.gradle") << """
            rootProject.name = 'test'
        """
    }

    def cleanup() {
        // unstopped instances of ProjectBuilderImpl projects leak build operations
        // causing other integration tests to sporadically fail.
        if (project != null) {
            ProjectBuilderImpl.stop(project)
        }
    }

    def "can resolve remote dependencies"() {

  In a nutshell:

  User Code ---> sql package (concrete types) ---> sql/driver (interfaces)
  Database Driver -> sql (to register) + sql/driver (implement interfaces)

* Make type casting/conversions consistent between all drivers. To
  achieve this, most of the conversions are done in the sql package,
  not in each driver. The drivers then only have to deal with a
  smaller set of types.

import java.net.Proxy
import java.net.Socket
import okhttp3.Connection
import okhttp3.Handshake
import okhttp3.HttpUrl
import okhttp3.Protocol
import okhttp3.Route

/**
 * The object that is asking for a connection. Either a call or a connect policy from the pool.
 */
interface ConnectionUser {
  fun addPlanToCancel(connectPlan: ConnectPlan)

  fun removePlanToCancel(connectPlan: ConnectPlan)

limitations under the License.
==============================================================================*/

#include "tensorflow/compiler/mlir/lite/experimental/tac/common/utils.h"

#include "llvm/Support/Casting.h"
#include "mlir/IR/OpDefinition.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/lite/experimental/tac/common/targets.h"
#include "tensorflow/compiler/mlir/lite/ir/tfl_ops.h"

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"
#include "xla/mlir_hlo/mhlo/IR/hlo_ops.h"

namespace mlir::quant::stablehlo {
namespace {

using quant::tensorflow::IsTFQintType;
using quant::tensorflow::IsTFUniformQuantizedOp;

#define GEN_PASS_DEF_VERIFYQUANTLEGALIZATION
#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/bridge/passes.h.inc"

	}
}

func TestCrashHandler(t *testing.T) {
	testCrashHandler(t, false)
}

func testDeadlock(t *testing.T, name string) {
	// External linking brings in cgo, causing deadlock detection not working.
	testenv.MustInternalLink(t, false)

	output := runTestProg(t, "testprog", name)
	want := "fatal error: all goroutines are asleep - deadlock!\n"
	if !strings.HasPrefix(output, want) {

     */
    enum LockMode {

        /**
         * On demand, single writer, no readers (on demand exclusive mode).
         * <br><br>
         *
         * Supports processes asking for access. Only one process can access the cache at a time.
         * <br><br>
         *

The main logic with ADRs is to describe (architectural) decisions made:

* To provide best practices and solutions we (as the *build tool* team) want to promote.
* To avoid asking the same thing multiple times during code review.
* To explain *rejected solutions*, for now, and future development, in case they are proposed again.

ADRs can be written by any team.

public abstract class AbstractJVMVersionTooNewFailureDescriber extends AbstractResolutionFailureDescriber<IncompatibleGraphVariantFailure> {
    /**
     * Returns the JVM version used in the comparison against the library that is causing the failure.
     *
     * @param failure the failure
     * @return the JVM version that is incompatible
     */
    protected abstract JavaVersion getJVMVersion(IncompatibleGraphVariantFailure failure);