if _, err := readDir("/tmp/non-existent-directory"); err != errFileNotFound {
		t.Fatalf("expected = %s, got: %s", errFileNotFound, err)
	}

	file := path.Join(os.TempDir(), "issue")
	if err := os.WriteFile(file, []byte(""), 0o644); err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(file)

	// Check if file is given.
	if _, err := readDir(path.Join(file, "mydir")); err != errFileNotFound {

func (e *Erasure) Encode(ctx context.Context, src io.Reader, writers []io.Writer, buf []byte, quorum int) (total int64, err error) {
	writer := &multiWriter{
		writers:     writers,
		writeQuorum: quorum,
		errs:        make([]error, len(writers)),
	}

	for {
		var blocks [][]byte
		n, err := io.ReadFull(src, buf)
		if err != nil {
			if !IsErrIgnored(err, []error{
				io.EOF,

	reader    io.Reader
	bytesRead int64
}

// Max bzip2 concurrency across calls. 50% of GOMAXPROCS.
var bz2Limiter = pbzip2.CreateConcurrencyPool((runtime.GOMAXPROCS(0) + 1) / 2)

func (r *countUpReader) Read(p []byte) (n int, err error) {
	n, err = r.reader.Read(p)
	atomic.AddInt64(&r.bytesRead, int64(n))
	return n, err
}

func (r *countUpReader) BytesRead() int64 {
	if r == nil {
		return 0
	}

            "defaults": {
               "custom": {
                  "fillOpacity": 10,
                  "gradientMode": "hue",
                  "showPoints": "never"
               },
               "unit": "bytes"
            }
         },
         "gridPos": {
            "h": 10,
            "w": 6,
            "x": 0,
            "y": 2
         },
         "id": 4,
         "interval": "5s",

     */
    boolean isRetainPayload ();


    /**
     * 
     * @return the raw response message
     */
    byte[] getRawPayload ();


    /**
     * @param rawPayload
     */
    void setRawPayload ( byte[] rawPayload );

	// Test if free version is created when SkipTier wasn't set on fi
	j := xlMetaV2Object{}
	j.MetaSys = make(map[string][]byte)
	j.MetaSys[metaTierName] = []byte("WARM-1")
	j.MetaSys[metaTierStatus] = []byte(lifecycle.TransitionComplete)
	j.MetaSys[metaTierObjName] = []byte("obj-1")
	if _, ok := j.InitFreeVersion(fi); !ok {
		t.Fatal("Expected a free version to be created")
	}

        this.sourceOffset = soff;
        this.targetOffset = toff;
        this.length = len;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode ( byte[] dst, int dstIndex ) {
        int start = dstIndex;
        SMBUtil.writeInt8(this.sourceOffset, dst, dstIndex);
        dstIndex += 8;

pkg bytes, func ContainsAny([]uint8, string) bool
pkg bytes, func ContainsRune([]uint8, int32) bool
pkg bytes, method (*Reader) Reset([]uint8)
pkg compress/flate, const HuffmanOnly = -2
pkg compress/flate, const HuffmanOnly ideal-int
pkg context, func Background() Context
pkg context, func TODO() Context
pkg context, func WithCancel(Context) (Context, CancelFunc)
pkg context, func WithDeadline(Context, time.Time) (Context, CancelFunc)

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package disk

import (
	"errors"
	"fmt"
	"syscall"
)

// GetInfo returns total and free bytes available in a directory, e.g. `/`.
func GetInfo(path string, _ bool) (info Info, err error) {
	s := syscall.Statfs_t{}
	err = syscall.Statfs(path, &s)
	if err != nil {
		return Info{}, err
	}

        helper
            .add(SHORT_NAME, false)
            .add(LONG_NAME, false)
            .addValue(true)
            .add(SHORT_NAME, (byte) 1)
            .add(LONG_NAME, (byte) 2)
            .addValue((byte) 3)
            .add(SHORT_NAME, 'A')
            .add(LONG_NAME, 'B')
            .addValue('C')
            .add(SHORT_NAME, (short) 4)
            .add(LONG_NAME, (short) 5)