return memoryRegion;
    }

    /**
     * Check if request is completed
     *
     * @return true if completed, false otherwise
     */
    public boolean isCompleted() {
        return completed;
    }

    /**
     * Mark request as completed
     */
    public void markCompleted() {
        this.completed = true;
    }

    /**
     * Mark request as failed with error
     *

            if (!completed) {
              completed = true
              progressListener.update(totalBytesWritten, contentLength(), completed)
            }
          }
        }

      val bufferedSink = forwardingSink.buffer()
      delegate.writeTo(bufferedSink)
      bufferedSink.flush()
    }
  }

  fun interface ProgressListener {
    fun update(
      bytesWritten: Long,

    assertSame(defaultThread.getThreadGroup(), thread.getThreadGroup());
    assertSame(defaultThread.getUncaughtExceptionHandler(), thread.getUncaughtExceptionHandler());

    assertFalse(completed);
    thread.start();
    thread.join();
    assertTrue(completed);

    // Creating a new thread from the same ThreadFactory will have the same
    // pool ID but a thread ID of 2.
    Thread thread2 = threadFactory.newThread(monitoredRunnable);

      }
      try {
        super.close()
        complete(null)
      } catch (e: IOException) {
        throw complete(e)!!
      }
    }

    /** If [e] is non-null, this will return a non-null value. */
    private fun complete(e: IOException?): IOException? {
      if (completed) return e
      completed = true
      return bodyComplete(
        bytesRead = bytesReceived,

	if len(ri.Targets) == 0 {
		return replication.StatusType("")
	}
	completed := 0
	for _, v := range ri.Targets {
		switch v.ReplicationStatus {
		case replication.Failed:
			return replication.Failed
		case replication.Completed:
			completed++
		}
	}
	if completed == len(ri.Targets) {
		return replication.Completed
	}
	return replication.Pending
}

}

// BucketReplicationStats represents inline replication statistics
// such as pending, failed and completed bytes in total for a bucket
type BucketReplicationStats struct {
	Stats map[string]*BucketReplicationStat `json:",omitempty"`
	// Completed size in bytes
	ReplicatedSize int64 `json:"completedReplicationSize"`
	// Total Replica size in bytes
	ReplicaSize int64 `json:"replicaSize"`

        if (!this.completed) {
            throw new CIFSException("Context is not established");
        }
        this.mechContext.verifyMIC(data, mic);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.SSPContext#isMICAvailable()
     */
    @Override
    public boolean isMICAvailable() {
        if (!this.completed) {
            return false;
        }

    assertSame(defaultThread.getThreadGroup(), thread.getThreadGroup());
    assertSame(defaultThread.getUncaughtExceptionHandler(), thread.getUncaughtExceptionHandler());

    assertFalse(completed);
    thread.start();
    thread.join();
    assertTrue(completed);

    // Creating a new thread from the same ThreadFactory will have the same
    // pool ID but a thread ID of 2.
    Thread thread2 = threadFactory.newThread(monitoredRunnable);

      assertTrue(queue.offer("blocksPutCallsUntilRemoved"));
      this.completed = new Completion(countdownInMillis);
      scheduleEnableWrites(this.queue, countdownInMillis);
    }

    /** Perform a {@code put} and assert that operation completed in the expected timeframe. */
    void putSuccessfully() {
      putUninterruptibly(queue, "");
      completed.assertCompletionExpected();
      assertEquals("", queue.peek());
    }

     * block is automatically generated from the ntstatus package.
     */

    /** The operation completed successfully */
    int NT_STATUS_SUCCESS = 0x00000000;
    /** The request is pending */
    int NT_STATUS_PENDING = 0x00000103;
    /** A notify change request is being completed and information is being returned */
    int NT_STATUS_NOTIFY_ENUM_DIR = 0x0000010C;