respBody, err := client.callWithContext(ctx, peerRESTMethodDownloadProfilingData, nil, nil, -1)
	if err != nil {
		return data, err
	}
	defer xhttp.DrainBody(respBody)
	err = gob.NewDecoder(respBody).Decode(&data)
	return data, err
}

// GetBucketStats - load bucket statistics
func (client *peerRESTClient) GetBucketStats(ctx context.Context, bucket string) (BucketStats, error) {

  }

  public void testRoundTripHashCodeUsingBaseEncoding() {
    HashCode hash1 = sha1().hashString("foo", US_ASCII);
    HashCode hash2 = HashCode.fromBytes(BaseEncoding.base16().lowerCase().decode(hash1.toString()));
    assertEquals(hash1, hash2);
  }

  public void testObjectHashCode() {
    HashCode hashCode42 = HashCode.fromInt(42);
    assertEquals(42, hashCode42.hashCode());
  }

	if rec.Code != http.StatusOK {
		t.Errorf("Expected to succeed but failed with %d", rec.Code)
	}

	results := madmin.InfoMessage{}
	err = json.NewDecoder(rec.Body).Decode(&results)
	if err != nil {
		t.Fatalf("Failed to decode set config result json %v", err)
	}

	if results.Region != globalMinioDefaultRegion {
		t.Errorf("Expected %s, got %s", globalMinioDefaultRegion, results.Region)
	}
}

        if (this.getErrorCode() != 0) {
            return 4;
        }

        try {
            this.securityDescriptor = new SecurityDescriptor();
            bufferIndex += this.securityDescriptor.decode(buffer, bufferIndex, len);
        } catch (final IOException ioe) {
            throw new RuntimeCIFSException(ioe.getMessage());
        }

        return bufferIndex - start;
    }

    @Override

        writeInt4(buffer, dataOffset, notificationFilter);
    }
    
    @Override
    public void decode(byte[] buffer, int offset, int length) {
        super.decode(buffer, offset, length);
        
        if (length > getStandardLeaseSize()) {
            // Decode directory-specific data
            int dataOffset = offset + getStandardLeaseSize();
            

import okhttp3.Request
import okhttp3.Response
import okhttp3.Route
import okhttp3.internal.connection.RealCall
import okio.Sink
import okio.Socket
import okio.Source

/** Encodes HTTP requests and decodes HTTP responses. */
interface ExchangeCodec {
  /** The connection or CONNECT tunnel that owns this codec. */
  val carrier: Carrier

  /** Returns true if the response body and (possibly empty) trailers have been received. */

    /**
     * Downloads a log file by its encoded ID.
     *
     * @param id the Base64 encoded filename of the log file to download
     * @return ActionResponse containing the log file stream
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public ActionResponse download(final String id) {
        final String filename = sanitizeFilename(new String(Base64.getDecoder().decode(id), StandardCharsets.UTF_8));

        final int bufferLength = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        final Decodable i = createInformation(this.expectInfoType, this.expectInfoClass);
        if (i != null) {
            i.decode(buffer, bufferOffset, bufferLength);
        }
        bufferIndex = Math.max(bufferIndex, bufferOffset + bufferLength);
        this.info = i;
        return bufferIndex - start;
    }

        for (int i = 0; i < getNumEntries(); i++) {
            results[i] = e = new FileBothDirectoryInfo(getConfig(), isUseUnicode());

            e.decode(buffer, bufferIndex, len);

            /*
             * lastNameOffset ends up pointing to either to
             * the exact location of the filename(e.g. Win98)

		// respBytes, _ := httputil.DumpResponse(resp, true)
		// fmt.Println(string(respBytes))
		return nil, errors.New(resp.Status)
	}

	claims := map[string]any{}
	if err = json.NewDecoder(resp.Body).Decode(&claims); err != nil {
		// uncomment this for debugging when needed.
		// reqBytes, _ := httputil.DumpRequest(req, false)
		// fmt.Println(string(reqBytes))
		// respBytes, _ := httputil.DumpResponse(resp, true)