println("apply INSTANCE = " + sys.getProperty("INSTANCE"))

                    // Call from closure
                    def cl = { p ->
                        println("\$p CLOSURE = " + sys.getProperty("CLOSURE"))
                    }
                    cl("apply")

                    project.tasks.register("thing") { t ->
                        t.doLast {

        def url2 = new URL("http://localhost/file2.jar")

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

        then:
        cl instanceof VisitableURLClassLoader
        cl.name == "test-client-payload-loader"
        cl.URLs == [url1, url2] as URL[]
    }

        Project.class.classLoader.loadClass('${implClassName}')
        def cl
        try {
            cl = getClass().classLoader
            cl.loadClass('${implClassName}')
            assert false: 'should fail'
        } catch (ClassNotFoundException e) {
            // expected
        } finally {
            if (cl instanceof URLClassLoader) {
                cl.close()
            }
        }

    private final PayloadClassLoaderRegistry delegate;

    static {
        ImmutableSet.Builder<ClassLoader> builder = ImmutableSet.builder();
        for (ClassLoader cl = PLATFORM_CLASS_LOADER; cl != null; cl = cl.getParent()) {
            builder.add(cl);
        }
        PLATFORM_CLASS_LOADERS = builder.build();
    }

    public WellKnownClassLoaderRegistry(PayloadClassLoaderRegistry delegate) {

      llvm::cl::desc("The minimum required number of elements in a weight "
                     "array to apply quantization.")};

  Option<QuantMethod> quantization_method_{
      *this, "quantization-method",
      llvm::cl::init(tensorflow::quantization::QuantizationMethod::
                         METHOD_DYNAMIC_RANGE_INT8),
      llvm::cl::desc("Choose quantization method."),

        def original2 = cl.thing(123)
        def result2 = recreate(original2).call()

        result2 == "123"
    }

    def "class can include only serializable lambda"() {
        given:
        def cl = transformAndLoad(ClassWithSerializableLambda, ClassWithSerializableLambda.SerializableThing)

        expect:
        def original = cl.thing(123)

        DefaultSerializer serializer = new DefaultSerializer(classLoader)

        Class cl = classLoader.parseClass('package org.gradle.cache; class TestObj implements Serializable { }')
        Object o = cl.newInstance(new Object[0])

        when:
        def r = serialize(o, serializer)

        then:
        cl.isInstance(r)
    }

### OpenBSD {#openbsd}

<!-- go.dev/issue/55999, CL 518629, CL 518630 -->
Go 1.23 adds experimental support for OpenBSD on 64-bit RISC-V (`GOOS=openbsd`, `GOARCH=riscv64`).

### ARM64 {#arm64}

<!-- go.dev/issue/60905, CL 559555 -->

                        }
                    })
                })
                cl.leaseFinish()
            }
            start {
                spec.thread.blockUntil.worker1
                spec.instant.worker2Ready
                def cl = workerLeaseService.startWorker()
                spec.instant.worker2
                cl.leaseFinish()
            }
        }

        then:

    description: >
      A CL containing proposed changes to the
      [config.txt](https://go.googlesource.com/telemetry/+/master/internal/chartconfig/config.txt)
      chart configuration.
      See the [chartconfig](https://pkg.go.dev/golang.org/x/telemetry/internal/chartconfig)
      package for an explanation of the chart config format.
      For an example change, see [CL 564619](https://go.dev/cl/564619).
  validations: