Did you *actually* encounter the need for this feature in a real-world scenario, or is it
        just a feature that seems like a sensible addition to Guava?


        Before new features get added to Guava, we really want to be sure that it's for a use case
        that actually comes up in the real world. We want to hear the real-world use case so the

	switch z := x.(type) {
	case complex64:
		re = float64(real(z))
		im = float64(imag(z))
	case complex128:
		re = real(z)
		im = imag(z)
	default:
		panic("unknown complex type")
	}
	return
}

func ComplexAbs[T Complex](a T) T {
	// TODO use direct conversion instead of realimag once #50937 is fixed
	r, i := realimag(a)
	// r := float64(real(a))
	// i := float64(imag(a))
	d := math.Sqrt(r*r + i*i)

	switch z := x.(type) {
	case complex64:
		re = float64(real(z))
		im = float64(imag(z))
	case complex128:
		re = real(z)
		im = imag(z)
	default:
		panic("unknown complex type")
	}
	return
}

func (a complexAbs[T]) Abs() T {
	// TODO use direct conversion instead of realimag once #50937 is fixed
	r, i := realimag(a.Value_)
	// r := float64(real(a.Value))
	// i := float64(imag(a.Value))

			false +
			float32 +
			float64 +
			imag +
			int +
			int8 +
			int16 +
			int32 +
			int64 +
			len +
			make +
			new +
			nil +
			panic +
			print +
			println +
			real +
			recover +
			rune +
			string +
			true +
			uint +
			uint8 +
			uint16 +
			uint32 +
			uint64 +
			uintptr +
			iota
	if n != NUM*(NUM-1)/2 {

The test backend uses real Web servers (`apache`, `nginx` and `tomcat`) configured to serve at the above predefined path.
If a fuzzer generated request successfully gets the data at the predefined path, it means a policy bypass has happened
otherwise it should have been rejected with 403 by the policy.

	TelemetryRetryDelay time.Duration
	// TelemetryRetryTimeout is the retry timeout used in tests.
	TelemetryRetryTimeout time.Duration
	// UseRealStackdriver controls whether to use real stackdriver backend for testing or not.
	UseRealStackdriver bool
)

func init() {
	flag.DurationVar(&TelemetryRetryDelay, "istio.test.telemetry.retryDelay", time.Second*2, "Default retry delay used in tests")

	finalWork fcrequest.SeatSeconds // only final work
}

// queue is a sequence of requests that have arrived but not yet finished
// execution in both the real and virtual worlds.
type queue struct {
	// The requestsWaiting not yet executing in the real world are stored in a FIFO list.
	requestsWaiting fifo

	// nextDispatchR is the R progress meter reading at
	// which the next request will be dispatched in the virtual world.

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

	n5 = len(<-c) // ERROR "is not a constant|is not constant"

	n6 = cap(f())  // ERROR "is not a constant|is not constant"
	n7 = cap(<-c) // ERROR "is not a constant|is not constant"
	n8 = real(z) // ERROR "is not a constant|is not constant"
	n9 = len([4]float64{real(z)}) // ERROR "is not a constant|is not constant"

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