Interface: &fakeIDX,
		Address: net.IPNet{
			IP: fakeIP,
		},
		Gateway: fakeGW,
	}
)

func TestPushCNIAddEventSucceed(t *testing.T) {
	// Fake out a test HTTP server and use that instead of a real HTTP server over gRPC to validate  req/resp flows
	testServer := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
		res.WriteHeader(http.StatusOK)
		res.Write([]byte("server happy"))
	}))

// complex ops
(ComplexReal (ComplexMake real _  )) => real
(ComplexImag (ComplexMake _ imag )) => imag

(Load <t> ptr mem) && t.IsComplex() && t.Size() == 8 =>
  (ComplexMake
    (Load <typ.Float32> ptr mem)
    (Load <typ.Float32>
      (OffPtr <typ.Float32Ptr> [4] ptr)
      mem)
    )
(Store {t} dst (ComplexMake real imag) mem) && t.Size() == 8 =>
  (Store {typ.Float32}

			StabilityLevel: compbasemetrics.ALPHA,
			Help:           "Number of errors when kubelet cannot compute SELinux context for a container that are ignored. They will become real errors when SELinuxMountReadWriteOncePod feature is expanded to all volume access modes.",
		},
		[]string{"access_mode"},
	)
	seLinuxPodContextMismatchErrors = compbasemetrics.NewGaugeVec(
		&compbasemetrics.GaugeOpts{

	},
	{
		"complex64",
		"Complex64",
		`real := float32FromBits(state.decodeUint(), ovfl)
		imag := float32FromBits(state.decodeUint(), ovfl)
		slice[i] = complex(float32(real), float32(imag))`,
	},
	{
		"complex128",
		"Complex128",
		`real := float64FromBits(state.decodeUint())
		imag := float64FromBits(state.decodeUint())
		slice[i] = complex(real, imag)`,
	},
	{
		"float32",
		"Float32",

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

            tasks.compileJava {
                options.fork = true
                options.forkOptions.jvmArgs = ['--not-a-real-argument']
            }
        """

        file('src/main/java/ClassToCompile.java') << """
            class ClassToCompile {
            }
        """

        when:

        this.commitDistributionsDir = commitDistributionsDir;
    }

    /**
     * `super.gradleHome` is not the real Gradle home but the directory which the commit distribution is unzipped into.
     * The real Gradle home is `gradle-7.5-commit-1a2b3c4/gradle-7.5-20220618071843+0000`.
     * @return
     */
    @Override
    TestFile getGradleHomeDir() {

type dryRunRange struct {
	real *Range
}

func (dry dryRunRange) Allocate(ip net.IP) error {
	return dry.real.allocate(ip, dryRunTrue)
}

func (dry dryRunRange) AllocateNext() (net.IP, error) {
	return dry.real.allocateNext(dryRunTrue)
}

func (dry dryRunRange) Release(ip net.IP) error {
	return dry.real.release(ip, dryRunTrue)
}

        buildFile << """
            task runInWorker(type: WorkerTask) {
                isolationMode = 'processIsolation'
                additionalForkOptions = { jvmArgs('--not-a-real-argument') }
                workActionClass = ${workAction.name}.class
            }
        """
    }

    def "worker startup failure messages are associated with the task that starts it"() {

			sym: "Baz",
		},
		{
			in:  "memeqbody",
			pkg: "",
			sym: "memeqbody",
		},
		{
			in:  `example%2ecom.Bar`,
			pkg: `example%2ecom`,
			sym: "Bar",
		},
		{
			// Not a real generated symbol name, but easier to catch the general parameter form.
			in:  `foo.Bar[sync/atomic.Uint64]`,
			pkg: `foo`,
			sym: "Bar[sync/atomic.Uint64]",
		},
		{
			in:  `example%2ecom.Bar[sync/atomic.Uint64]`,

	if err != nil {
		return fmt.Errorf("could not convert local virtual server to IPVS service: %w", err)
	}
	dst, err := toIPVSDestination(rs)
	if err != nil {
		return fmt.Errorf("could not convert local real server to IPVS destination: %w", err)
	}
	runner.mu.Lock()
	defer runner.mu.Unlock()
	return runner.ipvsHandle.NewDestination(svc, dst)
}

// DeleteRealServer is part of ipvs.Interface.