Buffer()
        .writeUtf8("\r\n--")
        .writeUtf8(boundary)
        .readByteString()

    private var partCount = 0
    private var closed = false
    private var noMoreParts = false

    /** This is only part that's allowed to read from the underlying source. */
    private var currentPart: PartSource? = null

    @Throws(IOException::class)
    constructor(response: ResponseBody) : this(

  private lateinit var handshakeEnabledCipherSuites: List<String>

  /** Ciphers in order we observed on sslSocketFactory defaults. */
  private lateinit var defaultEnabledCipherSuites: List<String>

  /** Ciphers in order we observed on sslSocketFactory supported. */
  private lateinit var defaultSupportedCipherSuites: List<String>

  val expectedModernTls12CipherSuites =

	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[batchJobMetricReplication-0]
	_ = x[batchJobMetricKeyRotation-1]
	_ = x[batchJobMetricExpire-2]
}

const _batchJobMetric_name = "ReplicationKeyRotationExpire"

var _batchJobMetric_index = [...]uint8{0, 11, 22, 28}

func (i batchJobMetric) String() string {

	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[healingMetricBucket-0]
	_ = x[healingMetricObject-1]
	_ = x[healingMetricCheckAbandonedParts-2]
}

const _healingMetric_name = "BucketObjectCheckAbandonedParts"

var _healingMetric_index = [...]uint8{0, 6, 12, 31}

func (i healingMetric) String() string {

	v := rebalanceInfo{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecoderebalanceInfo(b *testing.B) {
	v := rebalanceInfo{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

}

// StorageInfo returns disk information across all peers
func (sys *NotificationSys) StorageInfo(ctx context.Context, objLayer ObjectLayer, metrics bool) StorageInfo {
	var storageInfo StorageInfo
	replies := make([]StorageInfo, len(sys.peerClients))

	var wg sync.WaitGroup
	for i, client := range sys.peerClients {
		if client == nil {
			continue
		}
		wg.Add(1)
		go func(client *peerRESTClient, idx int) {

	}
	if c.Dir != "" {
		s += fmt.Sprintf(" [%s]", c.Dir)
	}
	return s
}

var internalPkg = regexp.MustCompile(`(^|/)internal($|/)`)

var exitCode = 0

func Check(t *testing.T) {
	checkFiles, err := filepath.Glob(filepath.Join(testenv.GOROOT(t), "api/go1*.txt"))
	if err != nil {
		t.Fatal(err)
	}

	var nextFiles []string

  ) {
    /** The server's time when the cached response was served, if known. */
    private var servedDate: Date? = null
    private var servedDateString: String? = null

    /** The last modified date of the cached response, if known. */
    private var lastModified: Date? = null
    private var lastModifiedString: String? = null

    /**

	{"[AX-X0]", "[AX-X0]"},
	{"[):[o-FP", ""}, // Issue 12469 - asm hung parsing the o-FP range on non ARM platforms.
}

var amd64RuntimeOperandTests = []operandTest{
	{"$bar<ABI0>(SB)", "$bar<ABI0>(SB)"},
	{"$foo<ABIInternal>(SB)", "$foo<ABIInternal>(SB)"},
}

var amd64BadOperandTests = []badOperandTest{
	{"[", "register list: expected ']', found EOF"},
	{"[4", "register list: bad low register in `[4`"},

	v := healingTracker{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodehealingTracker(b *testing.B) {
	v := healingTracker{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)