this.passphrase = passphrase;
    }

    /**
     * Get the absolute path to the private key file.
     *
     * @return absolute path to private key
     */
    public String getPrivateKey() {
        return privateKey;
    }

    /**
     * Set the absolute path to private key file.
     *
     * @param privateKey path to private key in local file system
     */

			t.Errorf("Test %d, expected %s, got %s", i, tc.out, x)
		}
	}
}

func TestPath(t *testing.T) {
	for _, path := range []string{"mydns", "skydns"} {
		result := msgPath("service.staging.skydns.local.", path)
		if result != etcdPathSeparator+path+"/local/skydns/staging/service" {
			t.Errorf("Failure to get domain's path with prefix: %s", result)
		}
	}
}

func TestUnPath(t *testing.T) {

            // Extract object name from path, removing leading slash if present and decoding URL encoding
            final String path = url.getPath();
            if (path != null && !path.isEmpty()) {
                final String pathWithoutLeadingSlash = path.startsWith("/") ? path.substring(1) : path;
                // Decode URL-encoded characters (e.g., %20 -> space)

        when(session.getAttribute("npa-workgroup")).thenReturn(auth);

        // Test various path formats
        String[] testPaths = { "/", "/workgroup/", "/workgroup/server/", "/workgroup/server/share/", "/workgroup/server/share/file.txt" };

        for (String path : testPaths) {
            when(request.getPathInfo()).thenReturn(path);

            assertDoesNotThrow(() -> networkExplorer.doGet(request, response));

            _dst.enc_ndr_referent(this.path, 1);
            _dst.enc_ndr_referent(this.comment, 1);
            _dst.enc_ndr_long(this.state);
            _dst.enc_ndr_long(this.num_stores);
            _dst.enc_ndr_referent(this.stores, 1);

            if (this.path != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(this.path);

            }

    /**
     * Attempt to reconnect a handle
     * @param path the file path
     * @param cause the original exception that triggered reconnection
     * @return a future that completes with the reconnected handle info or fails
     */
    public CompletableFuture<HandleInfo> reconnectHandle(String path, Exception cause) {
        HandleInfo info = handleManager.getHandleForReconnect(path);

        if (info == null) {

func guessIsLoginSTSReq(req *http.Request) bool {
	if req == nil {
		return false
	}
	return strings.HasPrefix(req.URL.Path, loginPathPrefix) ||
		(req.Method == http.MethodPost && req.URL.Path == SlashSeparator &&
			getRequestAuthType(req) == authTypeSTS)

      }

      override fun canonicalize(s: String): String = s.lowercase()
    },

    PATH {
      override fun urlString(value: String): String = "http://example.com/a${value}z/"

      override fun encodedValue(url: HttpUrl): String {
        val path = url.encodedPath
        return path.substring(2, path.length - 2)
      }

      override operator fun set(
        builder: HttpUrl.Builder,

        go-version: ${{ matrix.go }}

    - name: Check out code into the Go module directory
      uses: actions/checkout@v4

    - name: go mod package cache
      uses: actions/cache@v4
      with:
        path: ~/go/pkg/mod
        key: ${{ runner.os }}-go-${{ matrix.go }}-${{ hashFiles('tests/go.mod') }}

    - name: Tests
      run: GITHUB_ACTION=true GORM_DIALECT=sqlite ./tests/tests_all.sh

  mysql:
    strategy:

	EnvKESClientKey      = "MINIO_KMS_KES_KEY_FILE"     // Path to TLS private key for authenticating to KES with mTLS - usually prefer API keys
	EnvKESClientCert     = "MINIO_KMS_KES_CERT_FILE"    // Path to TLS certificate for authenticating to KES with mTLS - usually prefer API keys
	EnvKESServerCA       = "MINIO_KMS_KES_CAPATH"       // Path to file/directory containing CA certificates to verify the KES server certificate