// re-encoding them. (FIXME?)
		for k := range content.policies {
			content.policies[k] = nil
			gotContent.policies[k] = nil
		}
		if !reflect.DeepEqual(content.policies, gotContent.policies) {
			c.Fatalf("import %d: policies mismatch: expected: %v, got: %v", caseNum, content.policies, gotContent.policies)
		}
	}

	if !reflect.DeepEqual(content.ldapUserPolicyMappings, gotContent.ldapUserPolicyMappings) {

		{testBuckets[5], "201910/foo/bar/xl.meta/1.txt", "content", nil},
		{testBuckets[6], "aaa", "content", nil},
		{testBuckets[6], "bbb_aaa", "content", nil},
		{testBuckets[6], "bbb_aaa", "content", nil},
		{testBuckets[6], "ccc", "content", nil},
	}
	for _, object := range testObjects {
		md5Bytes := md5.Sum([]byte(object.content))

	}
	return false
}

func readAllXL(ctx context.Context, disks []StorageAPI, bucket, object string, readData, inclFreeVers bool) ([]FileInfo, []error) {
	rawFileInfos, errs := readAllRawFileInfo(ctx, disks, bucket, object, readData)
	return pickLatestQuorumFilesInfo(ctx, rawFileInfos, errs, bucket, object, readData, inclFreeVers)
}

func (z *erasureServerPools) StorageInfo(ctx context.Context, metrics bool) StorageInfo {
	return globalNotificationSys.StorageInfo(ctx, z, metrics)
}

func (z *erasureServerPools) NSScanner(ctx context.Context, updates chan<- DataUsageInfo, wantCycle uint32, healScanMode madmin.HealScanMode) error {
	// Updates must be closed before we return.
	defer xioutil.SafeClose(updates)

	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	globalIAMSys.Init(ctx, obj, globalEtcdClient, 2*time.Second)
	return obj, fsDirs[0], nil
}

func prepareErasureSets32(ctx context.Context) (ObjectLayer, []string, error) {
	return prepareErasure(ctx, 32)
}

func prepareErasure(ctx context.Context, nDisks int) (ObjectLayer, []string, error) {
	fsDirs, err := getRandomDisks(nDisks)
	if err != nil {
		return nil, nil, err
	}

    }


    /**
     * @param context
     * @param name
     */
    private void setContext ( SmbResource context, String name ) {
        this.fileLocator.resolveInContext(context.getLocator(), name);
        if ( context.getLocator().getShare() != null && ( context instanceof SmbFile ) ) {
            this.treeConnection = SmbTreeConnection.create( ( (SmbFile) context ).treeConnection);
        }
        else {

	if err = xlStorage.MakeVol(context.Background(), "exists-legacy"); err != nil {
		t.Fatalf("Unable to create a volume \"exists-legacy\", %s", err)
	}

	if err = xlStorage.AppendFile(context.Background(), "exists-legacy", "as-file/xl.json", []byte(legacyJSON)); err != nil {
		t.Fatalf("Unable to create a file \"as-file\", %s", err)
	}

			}
		})
	}
}

// Tests both object and bucket healing.
func TestHealing(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	obj, fsDirs, err := prepareErasure16(ctx)
	if err != nil {
		t.Fatal(err)
	}
	defer obj.Shutdown(context.Background())

	// initialize the server and obtain the credentials and root.
	// credentials are necessary to sign the HTTP request.

}

func (s *xlStorage) readMetadata(ctx context.Context, itemPath string) ([]byte, error) {
	return xioutil.WithDeadline[[]byte](ctx, globalDriveConfig.GetMaxTimeout(), func(ctx context.Context) ([]byte, error) {
		buf, _, err := s.readMetadataWithDMTime(ctx, itemPath)
		return buf, err
	})
}

	condValues["DurationSeconds"] = []string{strconv.FormatInt(int64(dur.Seconds()), 10)}
	return nil
}

func commonAddServiceAccount(r *http.Request, ldap bool) (context.Context, auth.Credentials, newServiceAccountOpts, madmin.AddServiceAccountReq, string, APIError) {
	ctx := r.Context()

	// Get current object layer instance.
	objectAPI := newObjectLayerFn()
	if objectAPI == nil || globalNotificationSys == nil {