// Test that we properly fall back to TCP when RDMA is not available
    CIFSContext context = getTestContext();
    context.getConfig().setProperty("jcifs.smb.client.useRDMA", "true");
    context.getConfig().setProperty("jcifs.smb.client.rdmaProvider", "nonexistent");
    
    SmbFile file = new SmbFile("smb://server/share/test.txt", context);
    
    // Should work even if RDMA provider is not available

        // Test with search field (content)
        PhraseQuery.Builder builder = new PhraseQuery.Builder();
        builder.add(new Term("content", "test"));
        PhraseQuery phraseQuery = builder.build();

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = queryCommand.convertPhraseQuery(context, phraseQuery, 1.0f);

        assertNotNull(result);

	return apiErr
}

// toAdminAPIErrCode - converts errErasureWriteQuorum error to admin API
// specific error.
func toAdminAPIErrCode(ctx context.Context, err error) APIErrorCode {
	if errors.Is(err, errErasureWriteQuorum) {
		return ErrAdminConfigNoQuorum
	}
	return toAPIErrorCode(ctx, err)
}

// wraps export error for more context
func exportError(ctx context.Context, err error, fname, entity string) APIError {

 */
@RunWith(AndroidJUnit4::class)
@SdkSuppress(minSdkVersion = 34)
class AndroidHttpEngineTest {
  val context = InstrumentationRegistry.getInstrumentation().context

  val cacheDir =
    context.cacheDir.resolve("httpEngine").also {
      it.mkdirs()
    }
  val engine =
    HttpEngine
      .Builder(context)
      .setEnableBrotli(true)
      .setStoragePath(cacheDir.path)

	}
	// Read a single byte.
	n, err = f.r.Read(p[:1])
	if n > 0 {
		t := time.Now()
		f.t = &t
	}
	return n, err
}

// Runs the speedtest on local MinIO process.
func selfSpeedTest(ctx context.Context, opts speedTestOpts) (res SpeedTestResult, err error) {
	objAPI := newObjectLayerFn()
	if objAPI == nil {
		return SpeedTestResult{}, errServerNotInitialized
	}

	var wg sync.WaitGroup
	var errOnce sync.Once

			if err != nil {
				return err
			}
		}

		// If the context does not contain the bucket key
		// we must add it for key generation. However,
		// the context must be stored exactly like the
		// client provided it. Therefore, we create a copy
		// of the client provided context and add the bucket
		// key, if not present.
		kmsCtx := kms.Context{}
		maps.Copy(kmsCtx, cryptoCtx)
		if _, ok := kmsCtx[bucket]; !ok {

package cmd

import (
	"bytes"
	"context"
	"crypto/md5"
	crand "crypto/rand"
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"runtime"
	"strconv"
	"testing"

	"github.com/dustin/go-humanize"
	"github.com/minio/minio/internal/config/storageclass"
)

func TestRepeatPutObjectPart(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	var objLayer ObjectLayer

func (c *lockRESTClient) RUnlock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCRUnlock, &args)
}

// Refresh calls Refresh REST API.
func (c *lockRESTClient) Refresh(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCRefresh, &args)
}

// Unlock calls write unlock RPC.

        .build()
    val call = proxyConfig.connect(server, client, url)
    assertContent("this response comes via a secure proxy", call.execute())
    val connect = server.takeRequest()
    assertThat(connect.requestLine, "Connect line failure on proxy")
      .isEqualTo("CONNECT android.com:443 HTTP/1.1")
    assertThat(connect.headers["Host"]).isEqualTo("android.com:443")
    val get = server.takeRequest()

    }

    /**
     * Creates a new CurlRequest with the CONNECT method for the specified URL.
     *
     * @param url the URL to connect to
     * @return a new CurlRequest object with the CONNECT method
     */
    public static CurlRequest connect(final String url) {
        return new CurlRequest(Method.CONNECT, url);
    }

    /**
     * Enumeration representing HTTP methods.