fillReady: make(chan int64),
	}

	go func() {
		var rpos int64 // total bytes read into buffer

		defer func() {
			atomic.StoreInt64(&sr.end, rpos)
			close(sr.fillReady)
		}()

		for range sr.fillReq {
		scan:
			n, err := r.Read(sr.nbuf[:])

			if n == 0 {
				switch err {
				case io.EOF: // reader is exhausted
					return
				case nil: // no data and no error, retry fill
					goto scan

    private long timeout;
    private LockingAndXRange[] locks;
    private LockingAndXRange[] unlocks;
    private boolean largeFile;

    /**
     * Creates a new SMB1 locking request for file byte-range locking operations.
     *
     * @param config the CIFS configuration
     */
    public SmbComLockingAndX(final Configuration config) {
        super(config);
    }

    /**
     * {@inheritDoc}
     *

| Maximum number of parts per upload                                              | 10,000                                                                          |
| Part size range                                                                 | 5 MiB to 5 TiB. Last part can be 0 B to 5 TiB                                   |

	keyCh := make(chan Key)

	go func() {
		defer xioutil.SafeClose(keyCh)

		retryTicker := time.NewTicker(retryInterval)
		defer retryTicker.Stop()

		for {
			for _, key := range store.List() {
				select {
				case keyCh <- key:
				// Get next key.
				case <-doneCh:
					return
				}
			}

			select {
			case <-retryTicker.C:
			case <-doneCh:
				return

# Try connecting to MinIO instance
{{- if .Values.tls.enabled }}
scheme=https
{{- else }}
scheme=http
{{- end }}
connectToMinio $scheme

{{ if .Values.users }}
{{ $global := . }}
# Create the users
{{- range .Values.users }}
echo {{ tpl .accessKey $global }} > $MINIO_ACCESSKEY_SECRETKEY_TMP
{{- if .existingSecret }}
cat /config/secrets/{{ tpl .existingSecret $global }}/{{ tpl .existingSecretKey $global }} >> $MINIO_ACCESSKEY_SECRETKEY_TMP

			// For IP only setups there is no need for DNS lookups.
			return baseDialCtx(ctx, "tcp", addr)
		}

		ips, err := lookupHost(ctx, host)
		if err != nil {
			return nil, err
		}

		for _, ip := range ips {
			conn, err = baseDialCtx(ctx, "tcp", net.JoinHostPort(ip, port))
			if err == nil {
				break
			}
		}

		return conn, err
	}

	var langs []Language
	if err := DB.Model(&user).Association("Languages").Find(&langs); err != nil {
		t.Fatalf("find languages: %v", err)
	}
	codeSet := map[string]bool{}
	for _, l := range langs {
		codeSet[l.Code] = true
	}
	for _, c := range []string{"am2m_map_1", "am2m_map_2", "am2m_map_3"} {
		if !codeSet[c] {
			t.Fatalf("expected language code %s present", c)
		}
	}
}

	<li>the index <code>x</code> is <i>in range</i> if <code>0 &lt;= x &lt; len(a)</code>,
	    otherwise it is <i>out of range</i></li>
</ul>

<p>
For <code>a</code> of <a href="#Array_types">array type</a> <code>A</code>:
</p>
<ul>
	<li>a <a href="#Constants">constant</a> index must be in range</li>
	<li>if <code>x</code> is out of range at run time,

		return
	}

	healthCtx, healthCancel := context.WithTimeout(ctx, deadline)
	defer healthCancel()

	healthInfoCh := make(chan madmin.HealthInfo)

	query := url.Values{}
	for _, k := range madmin.HealthDataTypesList {
		query.Set(string(k), "true")
	}

	healthInfo := madmin.HealthInfo{
		TimeStamp: time.Now().UTC(),
		Version:   madmin.HealthInfoVersion,
		Minio: madmin.MinioHealthInfo{

			expectedErr: errors.New("MasterKeyID contains unsupported characters"),
			shouldPass:  false,
		},
	}

	for i, tc := range testCases {
		ssec, err := ParseBucketSSEConfig(bytes.NewReader([]byte(tc.inputXML)))
		if tc.shouldPass && err != nil {
			t.Errorf("Test case %d: Expected to succeed but got %s", i+1, err)
		}