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,

	return
}

// DecodeMsg implements msgp.Decodable
func (z *ChecksumInfo) 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
		}

)

// DecodeMsg implements msgp.Decodable
func (z *BucketReplicationResyncStatus) 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
		}

     *             use actual Active Directory authentication instead
     */
    @Deprecated
    void logon(CIFSContext tc, Address dc, int port) throws CIFSException;

    /**
     * Get NTLM challenge from a server
     *
     * @param dc the domain controller address
     * @param tc the CIFS context containing credentials
     * @return NTLM challenge

			}
		case "Quorum":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Quorum")
					return
				}
				z.Quorum = nil
			} else {
				if z.Quorum == nil {
					z.Quorum = new(int)
				}
				*z.Quorum, err = dc.ReadInt()
				if err != nil {
					err = msgp.WrapError(err, "Quorum")
					return
				}
			}
		default:
			err = dc.Skip()
			if err != nil {

	v := allTierStats{}
	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 TestMarshalUnmarshalcurrentScannerCycle(t *testing.T) {
	v := currentScannerCycle{}

     */
    public UniAddress dc;

    NtlmChallenge(final byte[] challenge, final UniAddress dc) {
        this.challenge = challenge;
        this.dc = dc;
    }

    @Override
    public String toString() {
        return "NtlmChallenge[challenge=0x" + Hexdump.toHexString(challenge, 0, challenge.length * 2) + ",dc=" + dc.toString() + "]";
    }

			if err != nil {
				err = msgp.WrapError(err, "lastUpdate")
				return
			}
		case "b":
			z.bucket, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "bucket")
				return
			}
		case "flt":
			z.filter, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "filter")
				return
			}
		case "id":
			z.id, err = dc.ReadString()
			if err != nil {

	v := BatchJobReplicateCredentials{}
	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 TestMarshalUnmarshalBatchJobReplicateFlags(t *testing.T) {
	v := BatchJobReplicateFlags{}

    /**
     * Server address
     */
    public UniAddress dc;

    /**
     * Creates a new NTLM challenge with the specified parameters.
     * @param challenge the NTLM challenge bytes
     * @param dc the domain controller address
     */
    public NtlmChallenge(final byte[] challenge, final UniAddress dc) {
        this.challenge = challenge;
        this.dc = dc;
    }

    @Override
    public String toString() {