aws s3api --endpoint-url=https://localhost:9001 put-object --checksum-algorithm SHA256 --checksum-sha256 "${OBJ_CHKSUM}" --bucket test-bucket --key obj --body /tmp/data/obj --no-verify-ssl --profile enterprise

split -n 10 /tmp/data/mpartobj
CREATE_MPART_OUT=$(aws s3api --endpoint-url=https://localhost:9001 create-multipart-upload --bucket test-bucket --key mpartobj --checksum-algorithm SHA256 --no-verify-ssl --profile enterprise)

        assertArgumentNotNull("referenceClass", referenceClass);

        final URL url = ResourceUtil.getResource(toClassFile(referenceClass.getName()));
        final String[] path = referenceClass.getName().split("\\.");
        String baseUrl = url.toExternalForm();
        for (final String element : path) {
            final int pos = baseUrl.lastIndexOf('/');
            baseUrl = baseUrl.substring(0, pos);
        }

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.helper;

import static org.codelibs.core.stream.StreamUtil.split;
import static org.codelibs.core.stream.StreamUtil.stream;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.InetAddress;

        testEncoding(
            encoding.withSeparator(separator, sepLength),
            decoded,
            Joiner.on(separator).join(Splitter.fixedLength(sepLength).split(encoded)));
      }
    }
  }

  private static void testEncoding(BaseEncoding encoding, String decoded, String encoded) {
    testEncodes(encoding, decoded, encoded);

  // be one of the following values:
  // * Exact: Matches the URL path exactly.
  // * Prefix: Matches based on a URL path prefix split by '/'. Matching is
  //   done on a path element by element basis. A path element refers is the
  //   list of labels in the path split by the '/' separator. A request is a
  //   match for path p if every p is an element-wise prefix of p of the

        badWords = settings.badword().get(true);
        tagFieldNames = settings.getAsString(SuggestSettings.DefaultKeys.TAG_FIELD_NAME, StringUtil.EMPTY).split(",");
        roleFieldName = settings.getAsString(SuggestSettings.DefaultKeys.ROLE_FIELD_NAME, StringUtil.EMPTY);
        langFieldName = settings.getAsString(SuggestSettings.DefaultKeys.LANG_FIELD_NAME, StringUtil.EMPTY);

    }

    private CurlRequest getCurlRequest(final String header) {
        if (StringUtil.isBlank(header)) {
            return null;
        }

        final String[] values = header.split(" ");
        if (values.length != 2) {
            return null;
        }

        final String path;
        if (values[1].startsWith("/")) {
            path = values[1];
        } else {

		{"error", "error log", nil},
		{"info", "with labels", ptr.Of(float64(2))},
	}
	// For each level, there should be two lines, one from direct log,
	// the other one from UDS server
	gotLogs := strings.Split(
		strings.TrimSuffix(string(out), "\n"), "\n")
	if want, got := len(cases)*2, len(gotLogs); want != got {
		t.Fatalf("Number of logs want %v, got %v logs: %v", want, got, gotLogs)
	}
	i := 0
	for _, l := range gotLogs {

                                        list = new ArrayList<>();
                                        geoMap.put(geoField, list);
                                    }
                                    final String[] values = pt.split(",");
                                    if (values.length != 2) {
                                        throw new InvalidQueryException(

with values `REDUCED_REDUNDANCY` or `STANDARD`, MinIO server uses default parity values.

### Set metadata

In below example `minio-go` is used to set the storage class to `REDUCED_REDUNDANCY`. This means this object will be split across 6 data drives and 2 parity drives (as per the storage class set in previous step).

```go
s3Client, err := minio.New("localhost:9000", "YOUR-ACCESSKEYID", "YOUR-SECRETACCESSKEY", true)
if err != nil {