}

    @Test
    void testPublicShareAccess() throws Exception {
        // Test operations on public share
        SmbFile readmeFile = new SmbFile(baseUrl + "public/readme.txt", context);
        assertTrue(readmeFile.exists(), "File in public share should be accessible");
        assertTrue(readmeFile.canRead(), "File in public share should be readable");
    }

    // ========== Advanced Features ==========

    @Test

		return nil, err
	}
	defer done(0, &err)

	return p.storage.ListDir(ctx, origvolume, volume, dirPath, count)
}

// Legacy API - does not have any deadlines
func (p *xlStorageDiskIDCheck) ReadFile(ctx context.Context, volume string, path string, offset int64, buf []byte, verifier *BitrotVerifier) (n int64, err error) {
	ctx, done, err := p.TrackDiskHealth(ctx, storageMetricReadFile, volume, path)
	if err != nil {

func loadMetacacheSample(t testing.TB) *metacacheReader {
	b, err := os.ReadFile("testdata/metacache.s2")
	if err != nil {
		t.Fatal(err)
	}
	return newMetacacheReader(bytes.NewReader(b))
}

func loadMetacacheSampleEntries(t testing.TB) metaCacheEntriesSorted {
	r := loadMetacacheSample(t)

func readAndMap(files []string, partNum, blockNum int) (*mappedData, error) {
	var m mappedData
	sort.Strings(files)
	m.parityData = make(map[int]map[int][]byte)
	for _, file := range files {
		meta, err := os.ReadFile(file + ".json")
		if err != nil {
			return nil, err
		}
		type erasureInfo struct {
			V2Obj *struct {
				EcDist    []int
				EcIndex   int
				EcM       int
				EcN       int

package cmd

import (
	"bytes"
	"context"
	crand "crypto/rand"
	"io"
	"math/rand"
	"testing"

	"github.com/dustin/go-humanize"
)

func (a badDisk) ReadFile(ctx context.Context, volume string, path string, offset int64, buf []byte, verifier *BitrotVerifier) (n int64, err error) {
	return 0, errFaultyDisk
}

var erasureDecodeTests = []struct {
	dataBlocks                   int

pkg go/doc, func ToText //deprecated #51082
pkg io/ioutil, func NopCloser //deprecated #42026
pkg io/ioutil, func ReadAll //deprecated #42026
pkg io/ioutil, func ReadDir //deprecated #42026
pkg io/ioutil, func ReadFile //deprecated #42026
pkg io/ioutil, func TempDir //deprecated #42026
pkg io/ioutil, func TempFile //deprecated #42026
pkg io/ioutil, func WriteFile //deprecated #42026

        `tf.io.decode_compressed`, `tf.io.decode_json_example`,
        `tf.io.decode_raw`, `tf.io.encode_base64`, `tf.io.matching_files`,
        `tf.io.parse_tensor`, `tf.io.read_file,`tf.io.write_file`.
    *   New endpoints in tf.linalg namespace: `tf.linalg.cross`,
        `tf.linalg.tensor_diag` (corresponds to `tf.diag`),
        `tf.linalg.tensor_diag_part` (corresponds to `tf.diag_part`).

	if err != nil {
		t.Fatal(err)
	}

	for _, drive := range fsDirs {
		dir := path.Join(drive, bucket, object, uuid.String())
		_, err := os.ReadFile(pathJoin(dir, "part.1"))
		if err == nil {
			t.Fatal("expected data dit to be cleaned up")
		}
	}

	// Remove the bucket - to simulate the case where bucket was
	// created when the disk was down.

  fun explicitRemoveAppliedToDiskImmediately() {
    val editor = cache.edit("k1")!!
    editor.setString(0, "ABC")
    editor.setString(1, "B")
    editor.commit()
    val k1 = getCleanFile("k1", 0)
    assertThat(readFile(k1)).isEqualTo("ABC")
    cache.remove("k1")
    assertThat(filesystem.exists(k1)).isFalse()
  }

  @Test
  fun removePreventsActiveEditFromStoringAValue() {
    set("a", "a", "a")

			t.Errorf("Case %d failed: expected %v result %v", i, c.content, result.String())
		}
	}
}

type tester interface {
	Fatal(...any)
}

func openTestFile(t tester, file string) []byte {
	f, err := os.ReadFile("testdata/testdata.zip")
	if err != nil {
		t.Fatal(err)
	}
	z, err := zip.NewReader(bytes.NewReader(f), int64(len(f)))
	if err != nil {
		t.Fatal(err)
	}
	for _, f := range z.File {
		if f.Name == file {