}

func (h *healingTracker) isHealed(bucket string) bool {
	h.mu.RLock()
	defer h.mu.RUnlock()
	return slices.Contains(h.HealedBuckets, bucket)
}

// resume will reset progress to the numbers at the start of the bucket.
func (h *healingTracker) resume() {
	h.mu.Lock()
	defer h.mu.Unlock()

	h.ItemsHealed = h.ResumeItemsHealed
	h.ItemsFailed = h.ResumeItemsFailed
	h.ItemsSkipped = h.ResumeItemsSkipped

    /**
     * Gets the last file name in the response.
     *
     * @return the lastName
     */
    public final String getLastName() {
        return this.lastName;
    }

    /**
     * Gets the resume key for continuing the search.
     *
     * @return the resumeKey
     */
    public final int getResumeKey() {
        return this.resumeKey;
    }

    @Override

public class SrvCopychunkCopy implements Encodable {

    private final byte[] sourceKey;
    private final SrvCopychunk[] chunks;

    /**
     * Constructs a server copy chunk operation request
     * @param sourceKey the resume key identifying the source file
     * @param chunks the array of copy chunk descriptors
     */
    public SrvCopychunkCopy(final byte[] sourceKey, final SrvCopychunk... chunks) {
        this.sourceKey = sourceKey;

		if tracker.isHealed(bucket) {
			continue
		}

		var forwardTo string
		// If we resume to the same bucket, forward to last known item.
		b := tracker.getBucket()
		if b == bucket {
			forwardTo = tracker.getObject()
		}
		if b != "" {
			// Reset to where last bucket ended if resuming.
			tracker.resume()
		}
		tracker.setObject("")
		tracker.setBucket(bucket)

  @BeforeEach
  fun setUp() {
    // Default after JDK 14, but we are avoiding tests that assume special setup.
    // System.setProperty("jdk.tls.client.enableSessionTicketExtension", "true")
    // System.setProperty("jdk.tls.server.enableSessionTicketExtension", "true")

    // IllegalStateException: Cannot resume session and session creation is disabled
    platform.assumeNotBouncyCastle()
  }

  @Test

        log.debug("Trying server side copy");
        SmbFileHandleImpl dfd = null;
        try {
            long size;
            byte[] resumeKey;

            // despite there being a resume key, we still need an open file descriptor?
            try (SmbFileHandleImpl sfd =
                    src.openUnshared(0, SmbConstants.O_RDONLY, SmbConstants.FILE_SHARE_READ, SmbConstants.ATTR_NORMAL, 0)) {

## Résumé

         */
        public int prefmaxlen;
        /**
         * The total number of entries.
         */
        public int totalentries;
        /**
         * The resume handle for enumeration.
         */
        public int resume_handle;

        /**
         * Constructs a ShareEnumAll request.
         * @param servername the server name

		if pool.Decommission == nil {
			continue
		}
		if pool.Decommission.Complete || pool.Decommission.Canceled {
			// Do not resume decommission upon startup for
			// - decommission complete
			// - decommission canceled
			continue
		} // In all other situations we need to resume
		newPools = append(newPools, pool)
	}
	return newPools
}

func (p *poolMeta) DecommissionComplete(idx int) bool {

     * Constructs a Trans2FindNext2 request for continuing a file search.
     *
     * @param config the configuration to use
     * @param sid the search ID from a previous FindFirst2 response
     * @param resumeKey the resume key for continuing the search
     * @param filename the last filename from the previous response
     * @param batchCount the number of entries to return
     * @param batchSize the maximum size of the response buffer
     */