}

				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] {

		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,
				})

					}
					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
		}
	}

			}
			// 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",

	}
	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", "")

			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

  }

  void BuildGraphAndAddGradientsWithPrefixes(const char* prefix1,
                                             const char* prefix2 = nullptr) {
    TF_Output inputs[2];
    TF_Output outputs[1];
    TF_Output grad_outputs[2];

    BuildSuccessGraph(inputs, outputs);

    AddGradients(false, prefix1, inputs, 2, outputs, 1, grad_outputs);
    if (prefix2 != nullptr) {

// effect if a prefix is set, since the prefix will guarantee all names are
// unique. Defaults to false.
TF_CAPI_EXPORT extern void TF_ImportGraphDefOptionsSetUniquifyNames(
    TF_ImportGraphDefOptions* opts, unsigned char uniquify_names);

// If true, the specified prefix will be modified if it already exists as an
// operation name or prefix in the graph. If false, a conflicting prefix will be