)

// DecodeMsg implements msgp.Decodable
func (z *WalkDirOptions) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}

			Type:        "string",
			Sensitive:   true,
			Secret:      true,
		},
		config.HelpKV{
			Key:         UserDNSearchBaseDN,
			Description: `";" separated list of user search base DNs e.g. "dc=myldapserver,dc=com"` + defaultHelpPostfix(UserDNSearchBaseDN),
			Optional:    true,
			Type:        "list",
		},
		config.HelpKV{
			Key:         UserDNSearchFilter,

)

// DecodeMsg implements msgp.Decodable
func (z *BucketMetadata) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}

	v := RStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		err := v.DecodeMsg(dc)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func TestMarshalUnmarshalRTimedMetrics(t *testing.T) {
	v := RTimedMetrics{}

	v := connectReq{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		err := v.DecodeMsg(dc)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func TestMarshalUnmarshalconnectResp(t *testing.T) {
	v := connectResp{}

	// so nothing happens in the background.
	dc, _, err := f.newController(ctx)
	if err != nil {
		t.Fatalf("error creating Deployment controller: %v", err)
	}

	dc.addReplicaSet(klog.FromContext(ctx), rs1)
	if got, want := dc.queue.Len(), 1; got != want {
		t.Fatalf("queue.Len() = %v, want %v", got, want)
	}
	key, done := dc.queue.Get()
	if key == "" || done {

000003d0  bb 32 ca f6 61 b2 ef 5d  9c 2c 1b a5 10 66 7b fd  |.2..a..].,...f{.|
000003e0  4b d0 03 dc 53 a9 0d 5a  d5 c4 4c 25 9c 55 e6 f8  |K...S..Z..L%.U..|
000003f0  d1 d8 49 dc 36 a1 92 ae  f1 3e 2f 11 66 87 93 69  |..I.6....>/.f..i|
00000400  24 2e 5d 6c f6 79 15 68  a8 99 2e 1a 9c e2 85 4e  |$.]l.y.h.......N|
00000410  5f d6 a8 3c 70 e1 67 cb  df b2 1b ab 2b ed dc b6  |_..<p.g.....+...|
00000420  64 f4 bc 22 35 20 7f ff  64 b3 be d9 eb a1 ab 5d  |d.."5 ..d......]|

		fmt.Sprintf("server_addr=%s", serverAddr),
		"server_insecure=on",
		"lookup_bind_dn=cn=admin,dc=min,dc=io",
		"lookup_bind_password=admin",
		// `DC` is intentionally capitalized here.
		"user_dn_search_base_dn=DC=min,DC=io",
		"user_dn_search_filter=(uid=%s)",
		// `DC` is intentionally capitalized here.
		"group_search_base_dn=ou=swengg,DC=min,dc=io",
		"group_search_filter=(&(objectclass=groupofnames)(member=%d))",
	}

	v := rebalanceInfo{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		err := v.DecodeMsg(dc)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func TestMarshalUnmarshalrebalanceMeta(t *testing.T) {
	v := rebalanceMeta{}

00000130  9e 54 16 d6 71 0e b2 ea  4e 0f 13 f0 6e 63 88 e7  |.T..q...N...nc..|
00000140  9f 55 65 0b 00 00 00 00  00 21 20 21 c5 95 b2 62  |.Ue......! !...b|
00000150  61 dc b6 32 34 60 19 58  8c 6b 4b de dc 39 c7 d6  |a..24`.X.kK..9..|
00000160  82 55 c8 de 80 dc b7 05  0c be a6                 |.U.........|
>>> Flow 2 (server to client)
00000000  16 03 03 00 80 02 00 00  7c 03 03 00 00 00 00 00  |........|.......|