for (Repository repository : repositories) {
            validateStringNotEmpty(
                    prefix, prefix2, "id", problems, Severity.ERROR, Version.V20, repository.getId(), null, repository);

            if (validateStringNotEmpty(
                    prefix,
                    prefix2,
                    "[" + repository.getId() + "].url",
                    problems,

				}

				if len(testCase.result.Prefixes) != len(result.Prefixes) {
					t.Log(testCase, testCase.result.Prefixes, result.Prefixes)
					t.Fatalf("%s: Expected number of prefixes in the result to be '%d', but found '%d' prefixes instead", instanceType, len(testCase.result.Prefixes), len(result.Prefixes))
				}
				for j := 0; j < len(testCase.result.Prefixes); j++ {
					if testCase.result.Prefixes[j] != result.Prefixes[j] {

					}
					prefixes = append(prefixes, prefix)
				}
				if len(prefixes) > 0 {
					objInfo, _ := z.GetObjectInfo(ctx, bucket, pathJoin(opts.Prefix, "_SUCCESS"), ObjectOptions{NoLock: true})
					if objInfo.IsLatest && objInfo.DeleteMarker {
						return loi, nil
					}
				}
				li.Prefixes = prefixes
			}
			return li, nil
		}
	}

		objInfoCh := make(chan miniogo.ObjectInfo, 1)
		go func() {
			prefixes := r.Source.Prefix.F()
			if len(prefixes) == 0 {
				prefixes = []string{""}
			}
			for _, prefix := range prefixes {
				prefixObjInfoCh := c.ListObjects(ctx, r.Source.Bucket, miniogo.ListObjectsOptions{
					Prefix:       prefix,
					WithVersions: minioSrc,
					Recursive:    true,
					WithMetadata: true,
				})

			}
			// Asserting Prefix.
			if actualResult.Prefix != expectedResult.Prefix {
				t.Errorf("Test %d: %s: Expected Prefix to be \"%s\", but instead found it to be \"%s\"", i+1, instanceType, expectedResult.Prefix, actualResult.Prefix)
			}
			// Asserting Delimiter.
			if actualResult.Delimiter != expectedResult.Delimiter {

					return
				}
			}
		case "Prefixes":
			var zb0003 uint32
			zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Prefixes")
				return
			}
			if cap(z.Prefixes) >= int(zb0003) {
				z.Prefixes = (z.Prefixes)[:zb0003]
			} else {
				z.Prefixes = make([]string, zb0003)
			}
			for za0002 := range z.Prefixes {

	lc := Lifecycle{
		Rules: []Rule{
			{
				Status:     "Enabled",
				Filter:     Filter{Prefix: Prefix{string: "prefix-1", set: true}},
				Expiration: Expiration{Days: ExpirationDays(3)},
			},
			{
				Status:     "Enabled",
				Filter:     Filter{Prefix: Prefix{string: "prefix-1", set: true}},
				Expiration: Expiration{Date: midnightTS},
			},
			{
				Status:                      "Enabled",

			for _, n := range f.Names {
				name := n.Name
				if name == "_" {
					continue
				}
				if name != prefix {
					name = strings.TrimPrefix(n.Name, prefix)
				}
				name = upper(name)
				if names[name] {
					// Field name conflict: don't remove prefix.
					prefix = ""
					break fldLoop
				}
				names[name] = true
			}
		}
	}

	npad := 0

							<src>${project.build.directory}/fess</src>
							<excludes>**/fess_config.properties,**/fess_env*.properties,**/tika.xml</excludes>
							<mapper>
								<type>perm</type>
								<prefix>${packaging.fess.app.dir}</prefix>
								<filemode>755</filemode>
								<user>${packaging.fess.user}</user>
								<group>${packaging.fess.group}</group>
							</mapper>
						</data>
						<!-- Add libs -->
						<data>

	}
	if prefix != "" {
		queryValue.Set("prefix", prefix)
	}
	if delimiter != "" {
		queryValue.Set("delimiter", delimiter)
	}
	return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}

// return URL for a new multipart upload.
func getNewMultipartURL(endPoint, bucketName, objectName string) string {
	queryValue := url.Values{}
	queryValue.Set("uploads", "")