@get:JvmName("boundary") val boundary: String,
  ) : Closeable {
    /** This delimiter typically precedes the first part. */
    private val dashDashBoundary =
      Buffer()
        .writeUtf8("--")
        .writeUtf8(boundary)
        .readByteString()

    /**
     * This delimiter typically precedes all subsequent parts. It may also precede the first part
     * if the body contains a preamble.

	return fullBuffers, frag, totalLen, err
}

// ReadBytes reads until the first occurrence of delim in the input,
// returning a slice containing the data up to and including the delimiter.
// If ReadBytes encounters an error before finding a delimiter,
// it returns the data read before the error and the error itself (often io.EOF).
// ReadBytes returns err != nil if and only if the returned data does not end in
// delim.

			continue
		}
		if strings.HasPrefix(objName, prefix) {
			if count == maxKeys {
				isTruncated = true
				break
			}
			if delimiter != "" {
				i := strings.Index(objName[len(prefix):], delimiter)
				if i >= 0 {
					commonPrefix := objName[:len(prefix)+i+1]
					if len(listObjectsInfo.Prefixes) == 0 || commonPrefix != listObjectsInfo.Prefixes[len(listObjectsInfo.Prefixes)-1] {

			Bucket: bucket,
			Object: prefix,
		}
	}
	return nil
}

// Checks for all ListMultipartUploads arguments validity.
func checkListMultipartArgs(ctx context.Context, bucket, prefix, keyMarker, uploadIDMarker, delimiter string) error {
	if err := checkListObjsArgs(ctx, bucket, prefix, keyMarker); err != nil {
		return err
	}
	if uploadIDMarker != "" {
		if HasSuffix(keyMarker, SlashSeparator) {
			return InvalidUploadIDKeyCombination{

		b.off--
	}
	return nil
}

// ReadBytes reads until the first occurrence of delim in the input,
// returning a slice containing the data up to and including the delimiter.
// If ReadBytes encounters an error before finding a delimiter,
// it returns the data read before the error and the error itself (often io.EOF).
// ReadBytes returns err != nil if and only if the returned data does not end in
// delim.

  }
}

/**
 * Consumes and returns a non-empty token, terminating at special characters in
 * [TOKEN_DELIMITERS]. Returns null if the buffer is empty or prefixed with a delimiter.
 */
private fun Buffer.readToken(): String? {
  var tokenSize = indexOfElement(TOKEN_DELIMITERS)
  if (tokenSize == -1L) tokenSize = size

  return when {
    tokenSize != 0L -> readUtf8(tokenSize)
    else -> null
  }

    assertThat(part.headers).isEqualTo(headersOf())
    assertThat(part.body.readUtf8()).isEqualTo("abcd")

    assertThat(parts.nextPart()).isNull()
  }

  @Test fun `skip whitespace after close delimiter`() {
    val multipart =
      """
      |--simple boundary
      |
      |abcd
      |--simple boundary--
      """.trimMargin()

			expectedFields: map[string]struct{}{
				`connection_string="host=localhost port=2832"`: {},
				`comment="really long comment"`:                {},
			},
		},
		// Incorrect delimiter, expected fields should be empty.
		{
			input:          `comment:"really long comment" connection_string:"host=localhost port=2832"`,
			keys:           []string{"connection_string", "comment"},

      ],
      "CurrentTime": [
        "2022-05-07T18:31:41Z"
      ],
      "Delimiter": [
        "/"
      ],
      "EpochTime": [
        "1651948301"
      ],
      "Prefix": [
        ""
      ],
      "Referer": [
        ""
      ],
      "SecureTransport": [

	return gcsToObjectError(err, gcs.Bucket, key)
}

func (gcs *warmBackendGCS) InUse(ctx context.Context) (bool, error) {
	it := gcs.client.Bucket(gcs.Bucket).Objects(ctx, &storage.Query{
		Delimiter: "/",
		Prefix:    gcs.Prefix,
		Versions:  false,
	})
	pager := iterator.NewPager(it, 1, "")
	gcsObjects := make([]*storage.ObjectAttrs, 0)
	_, err := pager.NextPage(&gcsObjects)
	if err != nil {