// The global subnet config
	globalSubnetConfig subnet.Config

	// The global callhome config
	globalCallhomeConfig callhome.Config

	// The global drive config
	globalDriveConfig drive.Config

	// The global cache config
	globalCacheConfig cache.Config

	// Global server's network statistics
	globalConnStats = newConnStats()

	// Global HTTP request statistics

	if err != nil {
		return false, errors.New(log("Expander.NodeExpand failed to get CSI persistent source: %v", err))
	}

	csClient, err := newCsiDriverClient(csiDriverName(csiSource.Driver))
	if err != nil {
		// Treat the absence of the CSI driver as a transient error
		// See https://github.com/kubernetes/kubernetes/issues/120268
		return false, volumetypes.NewTransientOperationFailure(err.Error())
	}

class JavaExecWithLongCommandLineIntegrationTest extends AbstractIntegrationSpec {
    def veryLongFileNames = getLongCommandLine()

    def setup() {
        file("src/main/java/Driver.java") << """
            package driver;

            public class Driver {
                public static void main(String[] args) {}
            }
        """

        buildFile << """
            apply plugin: "java"

------------------------------------------------------------

mongodbSupportCompileClasspath - Compile classpath for source set 'mongodb support'.
\--- org.mongodb:mongodb-driver-sync:3.9.1
     +--- org.mongodb:bson:3.9.1
     \--- org.mongodb:mongodb-driver-core:3.9.1
          \--- org.mongodb:bson:3.9.1

            }
        }

        if (ResourceUtil.getResourceNoException("org/h2/Driver.class") != null) {
            list.add("h2");
        }

        if (ResourceUtil.getResourceNoException("com/mysql/jdbc/Driver.class") != null) {
            list.add("mysql");
        }

        if (ResourceUtil.getResourceNoException("oracle/jdbc/driver/OracleDriver.class") != null) {
            list.add("oracle");
        }

	"shadowstrict":        "shadow.strict",
	"unusedfuncs":         "unusedresult.funcs",
	"unusedstringmethods": "unusedresult.stringmethods",
}

// ---- output helpers common to all drivers ----

// PrintPlain prints a diagnostic in plain text form,
// with context specified by the -c flag.
func PrintPlain(fset *token.FileSet, diag analysis.Diagnostic) {
	posn := fset.Position(diag.Pos)

package tests_test

import (
	"log"
	"math/rand"
	"os"
	"path/filepath"
	"time"

	"gorm.io/driver/mysql"
	"gorm.io/driver/postgres"
	"gorm.io/driver/sqlite"
	"gorm.io/driver/sqlserver"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	. "gorm.io/gorm/utils/tests"
)

var DB *gorm.DB
var (
	mysqlDSN     = "gorm:gorm@tcp(localhost:9910)/gorm?charset=utf8&parseTime=True&loc=Local"

    licenses = ["notice"],
)

glob_lit_tests(
    name = "all_tests",
    data = [":test_utilities"],
    # Custom driver is unsupported in OSS. Fails if one is provided.
    # copybara:uncomment driver = "//tensorflow/compiler/mlir:run_lit.sh",
    # copybara:comment_begin(JitRt/Auto fusion depreciated)
    exclude = [
        "auto-fusion.mlir",

	yval := reflect.ValueOf(y)
	if xval.Kind() == reflect.Ptr && xval.IsNil() ||
		yval.Kind() == reflect.Ptr && yval.IsNil() {
		return false
	}

	if valuer, ok := x.(driver.Valuer); ok {
		x, _ = valuer.Value()
	}
	if valuer, ok := y.(driver.Valuer); ok {
		y, _ = valuer.Value()
	}
	return reflect.DeepEqual(x, y)
}

func ToString(value interface{}) string {
	switch v := value.(type) {
	case string:

	// Clear out the clients
	// The lookup to generate a new client will fail when it tries to query a driver with an unknown name
	csiMapper.csiClient = nil
	csiMapper.csiClientGetter.csiClient = nil
	// Note that prepareBlockMapperTest above will create a driver with a name of "test-driver"
	csiMapper.csiClientGetter.driverName = "unknown-driver"

	_, err = csiMapper.SetUpDevice()
	if err == nil {