MultipartBody
        .Builder()
        .addPart(headersOf("Foo", "Bar"), "Baz".toRequestBody(null))
        .build()
    assertThat(body.parts.size).isEqualTo(1)
    val part1Buffer = Buffer()
    val part1 = body.part(0)
    part1.body.writeTo(part1Buffer)
    assertThat(part1.headers).isEqualTo(headersOf("Foo", "Bar"))
    assertThat(part1Buffer.readUtf8()).isEqualTo("Baz")
  }

  @Test
  fun nonAsciiFilename() {

porter.png...

	NextPartNumberMarker int

	// Maximum number of parts that were allowed in the response.
	MaxParts int

	// Indicates whether the returned list of parts is truncated.
	IsTruncated bool

	// List of all parts.
	Parts []PartInfo

	// Any metadata set during InitMultipartUpload, including encryption headers.
	UserDefined map[string]string

	// ChecksumAlgorithm if set
	ChecksumAlgorithm string

        }
      };

  private static void checkResult(Joiner joiner, Iterable<Integer> parts, String expected) {
    assertEquals(expected, joiner.join(parts));
    assertEquals(expected, joiner.join(parts.iterator()));

    StringBuilder sb1FromIterable = new StringBuilder().append('x');
    joiner.appendTo(sb1FromIterable, parts);
    assertEquals("x" + expected, sb1FromIterable.toString());

      return specialCases.get(constantName);
    }
    List<String> parts = new ArrayList<>();
    for (String part : Splitter.on('_').split(constantName)) {
      if (!uppercaseAcronyms.contains(part)) {
        part = part.charAt(0) + Ascii.toLowerCase(part.substring(1));
      }
      parts.add(part);
    }
    return Joiner.on('-').join(parts);
  }

		Release string `json:"release"`
	} `json:"minio"`
	// Metadata map for current object `xl.meta`.
	Meta map[string]string `json:"meta,omitempty"`
	// Captures all the individual object `xl.meta`.
	Parts []ObjectPartInfo `json:"parts,omitempty"`

	// Dummy values used for legacy use cases.
	VersionID string `json:"versionId,omitempty"`
	DataDir   string `json:"dataDir,omitempty"` // always points to "legacy"
}

            return true;
        }

        // Check for standalone double dots that could be dangerous
        String[] parts = path.split("[\\\\/]");
        for (String part : parts) {
            if (".".equals(part) || "..".equals(part)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Normalize a path
     */

  request.url(url)

  data?.let {
    request.method(requestMethod, it.toRequestBody(mediaType()))
  }

  for (header in headers.orEmpty()) {
    val parts = header.split(':', limit = 2)
    if (!isSpecialHeader(parts[0])) {
      request.header(parts[0], parts[1])
    }
  }
  referer?.let {
    request.header("Referer", it)
  }
  request.header("User-Agent", userAgent)

  return request.build()
}

/**
 * Service interface to parse {@link Version} and {@link VersionRange}.
 *
 * @since 4.0.0
 */
@Experimental
public interface VersionParser extends Service {

    /**
     * Parses the specified version string, for example "1.0".
     *
     * @param version the version string to parse, must not be {@code null}
     * @return the parsed version, never {@code null}

	}

	var minModTime time.Time
	if minModTimeStr != "" {
		var e error
		minModTime, e = time.Parse(time.RFC3339, minModTimeStr)
		if e != nil {
			log.Fatalln("Unable to parse --modified-since:", e)
		}
	}

	u, err := url.Parse(endpoint)
	if err != nil {
		log.Fatalln(err)
	}

	secure := strings.EqualFold(u.Scheme, "https")