when:
        def cl = new URLClassLoader(classpath.asURLArray, factory.createFilteringClassLoader(getClass().classLoader, new FilteringClassLoader.Spec()))
        def c = cl.loadClass(DefaultClassLoaderFactoryTestHelper.name)

        then:
        c != DefaultClassLoaderFactoryTestHelper

        when:
        Thread.currentThread().contextClassLoader = cl
        c.getConstructor().newInstance().doStuff()

        then:

    def "can locate a known visual studio install on the path"() {
        def vsDir = tmpDir.createDir("vs")
        def compiler = vsDir.file("cl.exe")

        when:
        List<VisualStudioInstallCandidate> metadata = locator.getVisualStudioInstalls()

        then:
        1 * os.findInPath("cl.exe") >> compiler
        1 * versionDeterminer.getVisualStudioMetadataFromCompiler(compiler) >> vsMetadata(vsDir, "15.0")

        and:

}

func (l lastDayTierStats) merge(m lastDayTierStats) (merged lastDayTierStats) {
	cl := l.clone()
	cm := m.clone()

	if cl.UpdatedAt.After(cm.UpdatedAt) {
		cm.forwardTo(cl.UpdatedAt)
		merged.UpdatedAt = cl.UpdatedAt
	} else {
		cl.forwardTo(cm.UpdatedAt)
		merged.UpdatedAt = cm.UpdatedAt
	}

	for i := range cl.Bins {
		merged.Bins[i] = cl.Bins[i].add(cm.Bins[i])
	}

	return merged
}

        }

        acceptClass(classData, deserializeLambdaSizeEvaluator)

        return maxMethodSize
    }

    <T extends ClassVisitor> T acceptClass(Class cl, T visitor) {
        def fileName = cl.name.replace('.', '/') + ".class"
        byte[] classData = cl.classLoader.getResource(fileName).bytes
        acceptClass(classData, visitor)
        return visitor
    }

        buildFile << '''
class UnmanagedThing {
    def getSomeProp() {
        return this
    }
    def conf(Closure cl) {
        cl.delegate = this
        cl.call()
    }
}

class MyPlugin extends RuleSource {
    @Model
    UnmanagedThing thing() { return new UnmanagedThing() }
}
apply plugin: MyPlugin

model {
    thing {

<!-- https://go.dev/issue/62737 , https://golang.org/cl/576681,  https://golang.org/cl/577615 -->
The compiler in Go 1.23 can now overlap the stack frame slots of local variables
accessed in disjoint regions of a function, which reduces stack usage
for Go applications.

<!-- https://go.dev/cl/577935 -->
For 386 and amd64, the compiler will use information from PGO to align certain

#include "tensorflow/compiler/mlir/lite/schema/schema_generated.h"
#include "tensorflow/lite/c/c_api_types.h"

using llvm::cl::opt;

// NOLINTNEXTLINE
static opt<std::string> inputFileName(llvm::cl::Positional,
                                      llvm::cl::desc("<input file>"),
                                      llvm::cl::init("-"));

namespace mlir {
namespace {

TfLiteStatus QuantizeAnnotatedModel(llvm::StringRef buffer,

        def cl = isolated(PayloadInterface).loadClass(PayloadInterface.name)

        when:
        def serialized = originator.serialize(cl)
        def received = receiver.deserialize(serialized)

        then:
        received != cl
        received.name == cl.name
    }

    def "reuses ClassLoaders for multiple invocations"() {

        given:
        classpathTransformer.transform(_, _) >> [url1, url2]

        when:
        def cl = registry.getClassLoaderFor(new VisitableURLClassLoader.Spec("test", [url1, url2]), [null])

        then:
        cl instanceof VisitableURLClassLoader
        cl.URLs == [url1, url2] as URL[]
    }

    def "creates ClassLoader for jar classpath"() {
        def jarFile = tmpDir.createFile("file1.jar")

pkg crypto/tls, type ConnectionState struct, TLSUnique []uint8

# CL 153420045 crypto/x509: continue to recognise MaxPathLen of zero as "no value"., Adam Langley <******@****.***>
pkg crypto/x509, type Certificate struct, MaxPathLenZero bool

# CL 158950043 database/sql: add Drivers, returning list of registered drivers, Russ Cox <******@****.***>
pkg database/sql, func Drivers() []string