opts.PreserveETag = ""
		pInfo, err = api.PutObjectPart(ctx, tgtBucket, tgtObject, res.UploadID, i+1, pReader, opts)
		if err != nil {
			return err
		}
		if pInfo.Size != objInfo.Size {
			return fmt.Errorf("Part size mismatch: got %d, want %d", pInfo.Size, objInfo.Size)
		}
		uploadedParts = append(uploadedParts, CompletePart{
			PartNumber: pInfo.PartNumber,
			ETag:       pInfo.ETag,
		})
	}

		ReplicationStatusInternal:  o.ReplicationStatusInternal,
		VersionPurgeStatusInternal: o.VersionPurgeStatusInternal,
	}
	cinfo.UserDefined = make(map[string]string, len(o.UserDefined))
	maps.Copy(cinfo.UserDefined, o.UserDefined)
	return cinfo
}

func (o ObjectInfo) tierStats() tierStats {
	ts := tierStats{
		TotalSize:   uint64(o.Size),
		NumVersions: 1,
	}

	errs := make([]error, len(localDrives))
	infos := make([]DiskInfo, len(localDrives))
	for i, drive := range localDrives {
		infos[i], errs[i] = drive.DiskInfo(GlobalContext, DiskInfoOptions{})
	}
	infoMaps := make(map[string]madmin.DiskMetrics)
	for i := range infos {
		if infos[i].Metrics.TotalWaiting >= 1 && errors.Is(errs[i], errFaultyDisk) {
			infoMaps[infos[i].Endpoint] = madmin.DiskMetrics{

        netdfs.DfsInfo3 info3 = new netdfs.DfsInfo3();
        info3.path = "dfs_path";
        info3.comment = "dfs_comment";
        info3.state = netdfs.DFS_VOLUME_FLAVOR_AD_BLOB;
        info3.num_stores = 1;
        info3.stores = new netdfs.DfsStorageInfo[1];
        info3.stores[0] = new netdfs.DfsStorageInfo();
        info3.stores[0].state = netdfs.DFS_STORAGE_STATE_ACTIVE;

        assertEquals(expectedIndexNumber, fileInternalInfo.getIndexNumber());

        FileInternalInfo info2 = new FileInternalInfo();
        int bytesDecoded2 = info2.decode(buffer, 0, 15); // More than needed
        assertEquals(8, bytesDecoded2); // Should still return 8
        assertEquals(expectedIndexNumber, info2.getIndexNumber());
    }

    @Test
    @DisplayName("Test encode with initial state")

				quotaSize = int64(q.Quota)
			}
		}

		if quotaSize == 0 {
			info := objAPI.StorageInfo(ctx, true)
			info.Backend = objAPI.BackendInfo()

			ci.Capacity = int64(GetTotalUsableCapacity(info.Disks, info))
		} else {
			ci.Capacity = quotaSize
		}
		ci.Available = ci.Capacity - ci.Used

		buf = encodeResponse(&ci)
	default:
		return nil, errFileNotFound
	}

	etag := getMD5Hash(buf)

            final int _infop = _src.dec_ndr_long();
            if (_infop != 0) {
                _src.dec_ndr_short(); /* union discriminant */
                this.info.decode(_src);

            }
            this.retval = _src.dec_ndr_long();
        }
    }

    /**
     * LSA lookup SIDs message.
     */
    public static class LsarLookupSids extends DcerpcMessage {

        @Override

            }
            _dst.enc_ndr_referent(this.totalentries, 1);
            if (this.totalentries != null) {
                this.totalentries.encode(_dst);

            }
        }

        @Override
        public void decode_out(final NdrBuffer _src) throws NdrException {
            final int _infop = _src.dec_ndr_long();
            if (_infop != 0) {

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.smb1;

interface Info {
    int getAttributes();

    long getCreateTime();

    long getLastWriteTime();

    long getSize();

	if err != nil {
		writeErrorResponseJSON(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	buckets := make([]string, 0, len(bucketInfos))
	for _, bInfo := range bucketInfos {
		buckets = append(buckets, bInfo.Name)
	}

	var id string
	if id, err = pools.initRebalanceMeta(ctx, buckets); err != nil {
		writeErrorResponseJSON(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}