def classesDir2 = file("actions/2")
        copyClassTo(Action2, classesDir2)
        def cl = actionClassLoader(classesDir1, classesDir2)
        def action1 = cl.loadClass(Action1.name)
        assert action1 != Action1
        def action2 = cl.loadClass(Action2.name)
        assert action2 != Action2

        expect:
        def l1 = withConnection {

        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)
    }

    def "loads class once and caches result"() {
        when:
        def cl = classLoader.loadClass("someClass")

        then:
        cl == String.class

        and:
        1 * parent.loadClass("someClass", false) >> String.class
        0 * parent._

        when:
        cl = classLoader.loadClass("someClass")

        then:
        cl == String.class

        and:
        0 * parent._
    }

		var h1 *HelmReconciler
		cl := fake.NewClientBuilder().WithInterceptorFuncs(interceptorFunc).Build()
		// init two custom gateways with revision
		gateways := [][]byte{iopTestGwData1, iopTestGwData2}
		for i, data := range gateways {
			iop := &v1alpha1.IstioOperator{}
			err := yaml.UnmarshalStrict(data, iop)
			assert.NoError(t, err)
			h := &HelmReconciler{
				client:     cl,

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

        then:

### 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 -->

    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:

func TestParseContentLength(t *testing.T) {
	tests := []struct {
		cl      string
		wantErr error
	}{
		{
			cl:      "",
			wantErr: badStringError("invalid empty Content-Length", ""),
		},
		{
			cl:      "3",
			wantErr: nil,
		},
		{
			cl:      "+3",
			wantErr: badStringError("bad Content-Length", "+3"),
		},
		{
			cl:      "-3",
			wantErr: badStringError("bad Content-Length", "-3"),

        repository.put('class1', value1)
        repository.put('class2', value2)
        Closure cl = Mock()

        when:
        repository.each(cl)

        then:
        1 * cl.call(['class1', value1] as Object[])
        1 * cl.call(['class2', value2] as Object[])
        0 * cl._
    }

    def canIterateOverClassesUsingAction() {
        TestDomainObject value1 = new TestDomainObject('a')