// GoString produces a golang source expression of the value.
func (pls *priorityLevelState) GoString() string {
	if pls == nil {
		return "nil"
	}
	return fmt.Sprintf("&priorityLevelState{pl:%s, qsCompleter:%#+v, queues:%#+v, quiescing:%#v, numPending:%d}", fcfmt.Fmt(pls.pl), pls.qsCompleter, pls.queues, pls.quiescing, pls.numPending)

		},
		{
			auds:     Audiences{"foo", "bar"},
			tauds:    Audiences{"foo", "wat"},
			expected: Audiences{"foo"},
		},
		{
			auds:     Audiences{"foo", "bar"},
			tauds:    Audiences{"pls", "wat"},
			expected: Audiences{},
		},
	}
	for _, c := range cs {
		t.Run("auds", func(t *testing.T) {
			if got, want := c.auds.Intersect(c.tauds), c.expected; !reflect.DeepEqual(got, want) {

				}
			}
		}
	}
	startWG.Wait()
}

func genPLs(rng *rand.Rand, trial string, oldPLNames sets.String, n int) (pls []*flowcontrol.PriorityLevelConfiguration, plMap map[string]*flowcontrol.PriorityLevelConfiguration, goodNames, badNames sets.String) {
	pls = make([]*flowcontrol.PriorityLevelConfiguration, 0, n)
	plMap = make(map[string]*flowcontrol.PriorityLevelConfiguration, n)
	goodNames = sets.NewString()

				InformerFactory:   informerFactory,
				FlowcontrolClient: flowcontrolClient,
				// for the purposes of this test, serverCL ~= nominalCL since there is
				// only 1 PL with large concurrency shares, making mandatory PLs negligible.
				ServerConcurrencyLimit: testcase.nominalCL,
				ReqsGaugeVec:           metrics.PriorityLevelConcurrencyGaugeVec,
				ExecSeatsGaugeVec:      metrics.PriorityLevelExecutionSeatsGaugeVec,

	out := append([]byte{'"'}, b...)
	out = append(out, '"')
	return out, nil
}

func (l *PodPortList) UnmarshalJSON(data []byte) error {
	var pl []PodPort
	pls, err := strconv.Unquote(string(data))
	if err != nil {
		return err
	}
	if err := json.Unmarshal([]byte(pls), &pl); err != nil {
		return err
	}
	*l = pl
	return nil
}

// StringBool defines a boolean that is serialized as a string for legacy reasons

			return
		}
		switch msgp.UnsafeString(field) {
		case "v":
			z.Version, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Version")
				return
			}
		case "pls":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Pools")
				return
			}
			if cap(z.Pools) >= int(zb0002) {
				z.Pools = (z.Pools)[:zb0002]

	}
}

func TestDroppedRequestsTrackerPLIndependent(t *testing.T) {
	fakeClock := testingclock.NewFakeClock(time.Now())
	tracker := newDroppedRequestsTracker(fakeClock.Now)

	// Report single dropped requests in multiple PLs.
	// Validate if RetryAfter isn't bumped next second.
	for i := 0; i < 10; i++ {
		tracker.RecordDroppedRequest(fmt.Sprintf("pl-%d", i))
	}
	fakeClock.Step(time.Second)
	for i := 0; i < 10; i++ {

	}
}

func portLevelSettingsConsistentHash(dst *networking.Destination,
	pls []*networking.TrafficPolicy_PortTrafficPolicy,
) *networking.LoadBalancerSettings_ConsistentHashLB {
	if dst.Port != nil {
		portNumber := dst.GetPort().GetNumber()
		for _, setting := range pls {
			number := setting.GetPort().GetNumber()
			if number == portNumber {

		LastUpdate:   ps.LastUpdate,
		Decommission: ps.Decommission.Clone(),
	}
}

//go:generate msgp -file $GOFILE -unexported
type poolMeta struct {
	Version int          `msg:"v"`
	Pools   []PoolStatus `msg:"pls"`

	// Value should not be saved when we have not loaded anything yet.
	dontSave bool `msg:"-"`
}

// A decommission resumable tells us if decommission is worth
// resuming upon restart of a cluster.

				"application/pkcs7-mime",
				"application/pkcs7-signature",
				"application/pkix-cert",
				"application/pkix-crl",
				"application/pkix-pkipath",
				"application/pkixcmp",
				"application/pls+xml",
				"application/poc-settings+xml",
				"application/postscript",
				"application/prs.alvestrand.titrax-sheet",
				"application/prs.cww",
				"application/prs.nprend",
				"application/prs.plucker",