// We may have reads that aren't locked, so update atomically.
	gotState := atomic.LoadUint32((*uint32)(&c.state))
	if gotState == StateShutdown || State(gotState) == s {
		return
	}
	if s == StateConnected {
		atomic.StoreInt64(&c.LastPong, time.Now().UnixNano())
	}
	atomic.StoreUint32((*uint32)(&c.state), uint32(s))
	if debugPrint {
		fmt.Println(c.Local, "updateState:", gotState, "->", s)
	}

  // metric is configured.  Scaling is active as long as at least one metric value is
  // available.
  // +optional
  optional int32 minReplicas = 2;

  // maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up.
  // It cannot be less that minReplicas.
  optional int32 maxReplicas = 3;

  // metrics contains the specifications for which to use to calculate the

	doTestParallelReaders(1, 4)
	doTestParallelReaders(3, 4)
	doTestParallelReaders(4, 2)
}

// Borrowed from rwmutex_test.go
func reader(resource string, numIterations int, activity *int32, cdone chan bool) {
	rwm := NewDRWMutex(ds, resource)
	for i := 0; i < numIterations; i++ {
		if rwm.GetRLock(context.Background(), nil, id, source, Options{Timeout: time.Second}) {
			n := atomic.AddInt32(activity, 1)

  // +optional
  optional int32 handSize = 2;

  // `queueLengthLimit` is the maximum number of requests allowed to
  // be waiting in a given queue of this priority level at a time;
  // excess requests are rejected.  This value must be positive.  If
  // not specified, it will be defaulted to 50.
  // +optional
  optional int32 queueLengthLimit = 3;
}

  // +optional
  optional int32 handSize = 2;

  // `queueLengthLimit` is the maximum number of requests allowed to
  // be waiting in a given queue of this priority level at a time;
  // excess requests are rejected.  This value must be positive.  If
  // not specified, it will be defaulted to 50.
  // +optional
  optional int32 queueLengthLimit = 3;
}

		BoolField          bool
		IntField           int
		Int8Field          int8
		Int16Field         int16
		Int32Field         int32
		Int64Field         int64
		UIntField          uint
		UInt8Field         uint8
		UInt16Field        uint16
		UInt32Field        uint32
		UInt64Field        uint64
		Float32Field       float32
		Float64Field       float64
		StringField        string

)

// T is the test logger.
var T = &testLogger{}

func init() {
	logger.AddSystemTarget(context.Background(), T)
}

type testLogger struct {
	current atomic.Pointer[testing.TB]
	action  atomic.Int32
}

// SetLogTB will set the logger to output to tb.
// Call the returned function to disable logging.
func (t *testLogger) SetLogTB(tb testing.TB) func() {
	return t.setTB(tb, logMessage)
}

	doTestParallelReaders(1, 4)
	doTestParallelReaders(3, 4)
	doTestParallelReaders(4, 2)
}

// Borrowed from rwmutex_test.go
func reader(rwm *LRWMutex, numIterations int, activity *int32, cdone chan bool) {
	for i := 0; i < numIterations; i++ {
		if rwm.GetRLock(context.Background(), "", "", time.Second) {
			n := atomic.AddInt32(activity, 1)
			if n < 1 || n >= 10000 {

	if err != nil {
		return nil, err
	}
	if len(metadata) > MaxMetadataSize {
		return nil, errors.New("config: encryption metadata is too large")
	}
	header[0] = Version
	binary.LittleEndian.PutUint32(header[1:], uint32(len(metadata)))
	buffer.Write(header[:])
	buffer.Write(metadata)

	return io.MultiReader(
		&buffer,
		stream.EncryptReader(plaintext, nonce, nil),
	), nil
}

// If cycles is 0 false is always returned.
// If cycles is 1 true is always returned (as expected).
func (h dataUsageHash) mod(cycle uint32, cycles uint32) bool {
	if cycles <= 1 {
		return cycles == 1
	}
	return uint32(xxhash.Sum64String(string(h)))%cycles == cycle%cycles
}

// modAlt returns true if the hash mod cycles == cycle.
// This is out of sync with mod.