Pools     []rebalancePoolStatus `json:"pools"` // contains all pools, including inactive
	StoppedAt time.Time             `json:"stoppedAt"`
}

func rebalanceStatus(ctx context.Context, z *erasureServerPools) (r rebalanceAdminStatus, err error) {
	// Load latest rebalance status
	meta := &rebalanceMeta{}
	err = meta.load(ctx, z.serverPools[0])
	if err != nil {
		return r, err
	}

    /**
     * @throws Exception
     */
    public void testGetContentsAsStream() throws Exception {
        final String contents = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><foo/>";
        assertNotNull("1", DomUtil.getContentsAsStream(contents, "UTF-8"));
    }

    /**
     * @throws Exception
     */
    public void testToString() throws Exception {

			}
		case "Key":
			z.Key, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Key")
				return
			}
		case "Context":
			z.Context, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Context")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

<!--- and make sure you have followed https://github.com/minio/minio/tree/release/docs/debugging to capture relevant logs -->

1.
2.
3.
4.

## Context
<!--- How has this issue affected you? What are you trying to accomplish? -->
<!--- Providing context helps us come up with a solution that is most useful in the real world -->

## Regression
<!-- Is this issue a regression? (Yes / No) -->

   *     Storage overview</a> to select an appropriate temporary directory (perhaps {@code
   *     context.getCacheDir()}), and create your own directory under that. (For example, you might
   *     use {@code new File(context.getCacheDir(), "directoryname").mkdir()}, or, if you need an
   *     arbitrary number of temporary directories, you might have to generate multiple directory

        loc.type = this.type;
        return loc;
    }

    /**
     * @param context
     * @param name
     */
    void resolveInContext(final SmbResourceLocator context, String name) {
        final String shr = context.getShare();
        if (shr != null) {
            this.dfsReferral = context.getDfsReferral();
        }
        final int last = name.length() - 1;

                }

                // Clear encryption context
                if (this.encryptionContext != null) {
                    try {
                        this.encryptionContext = null;
                    } catch (Exception e) {
                        log.debug("Error clearing encryption context during emergency cleanup", e);
                    }
                }
            }

		// Empty Content-Md5 header.
		{mustNewSignedEmptyMD5Request(http.MethodPut, "http://127.0.0.1:9000/", 5, bytes.NewReader([]byte("hello")), t), ErrInvalidDigest},
		// Short Content-Md5 header.
		{mustNewSignedShortMD5Request(http.MethodPut, "http://127.0.0.1:9000/", 5, bytes.NewReader([]byte("hello")), t), ErrInvalidDigest},
		// When request is properly signed, but has bad Content-MD5 header.

            // In a real implementation, this should be passed from the session context
            jcifs.CIFSContext context = createDefaultContext();

            // Create transport with multi-channel specific settings
            // Multi-channel transports should use signing consistently with the main session
            boolean forceSigning = context.getConfig().isSigningEnforced();

	"github.com/minio/minio/internal/dsync"
)

func TestLocalLockerExpire(t *testing.T) {
	wResources := make([]string, 1000)
	rResources := make([]string, 1000)
	quorum := 0
	l := newLocker()
	ctx := t.Context()
	for i := range wResources {
		arg := dsync.LockArgs{
			UID:       mustGetUUID(),
			Resources: []string{mustGetUUID()},
			Source:    t.Name(),
			Owner:     "owner",
			Quorum:    &quorum,
		}