}

// Parts returns the number of object parts that are
// referenced by this ETag. It returns 1 if the object
// has been uploaded using the S3 singlepart API.
//
// Parts may panic if the ETag is an invalid multipart
// ETag.
func (e ETag) Parts() int {
	if !e.IsMultipart() {
		return 1
	}

	n := bytes.IndexRune(e, '-')
	parts, err := strconv.Atoi(string(e[n+1:]))

        if (line.isEmpty() || line.startsWith("#")) continue

        var i = 0
        val parts = line.split(Regex(" ")).toTypedArray()

        val element = WebPlatformUrlTestData()
        element.input = unescape(parts[i++])

        val base = if (i < parts.size) parts[i++] else null
        element.base =
          when {
            base == null || base.isEmpty() -> list[list.size - 1].base

	dataErrsByDisk = make(map[int][]int, len(onlineDisks))
	for i := range onlineDisks {
		dataErrsByDisk[i] = make([]int, len(latestMeta.Parts))
	}

	dataErrsByPart = make(map[int][]int, len(latestMeta.Parts))
	for i := range latestMeta.Parts {
		dataErrsByPart[i] = make([]int, len(onlineDisks))
	}

	inconsistent := 0
	for i, meta := range partsMetadata {
		if !meta.IsValid() {

		}
		switch msgp.UnsafeString(field) {
		case "Parts":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Parts")
				return
			}
			if cap(z.Parts) >= int(zb0002) {
				z.Parts = (z.Parts)[:zb0002]
			} else {
				z.Parts = make([]CompletePart, zb0002)
			}
			for za0001 := range z.Parts {
				bts, err = z.Parts[za0001].UnmarshalMsg(bts)

func (config Config) String() string {
	parts := []string{
		fmt.Sprintf("Enabled: %v", config.Enabled()),
	}
	if config.Rule != nil {
		if config.Rule.DefaultRetention.Mode != "" {
			parts = append(parts, fmt.Sprintf("Mode: %s", config.Rule.DefaultRetention.Mode))
		}
		if config.Rule.DefaultRetention.Days != nil {
			parts = append(parts, fmt.Sprintf("Days: %d", *config.Rule.DefaultRetention.Days))
		}

            # (a subdirectory under docs_src/<topic>/)
            parts = py_file.relative_to(docs_src_path).parts
            if len(parts) > 2:
                # File is inside a sub-package like docs_src/topic/app_xxx/...
                package_root = docs_src_path / parts[0] / parts[1]
                used_package_dirs.add(package_root)
    removed = 0

            });

            if (classFile.contains("$")) {
                // for inner classes, also need to adjust the parent
                String[] parts = classFile.split("\\$");
                String parentClassFile = parts[0] + ".class";
                String innerClass = parts[1].split("\\.")[0];
                adjustClass(parentClassFile, classNode -> makeInnerClassPublic(classNode, innerClass));
            }
        }
    }

	// returned by the server).
	z := obj.(*erasureServerPools)
	xl := z.serverPools[0].sets[0]
	erasureDisks := xl.getDisks()
	parts, errs := readAllFileInfo(ctx, erasureDisks, "", bucketName, objectName, "", false, false)
	for i := range parts {
		if errs[i] == nil {
			if parts[i].Name == objectName {
				t.Errorf("path traversal allowed to allow writing to minioMetaBucket: %s", instanceType)
			}
		}
	}
}

			t.Fatalf("Test failed to decode XML response: <ERROR> %v", err)
		}

		parts = append(parts, CompletePart{
			PartNumber: partNumber,
			ETag:       canonicalizeETag(resp.ETag),
		})
	}

	var completeBytes []byte
	// Complete multipart upload parts.
	completeUploads := &CompleteMultipartUpload{
		Parts: parts,
	}
	completeBytes, err = xml.Marshal(completeUploads)
	if err != nil {

        // This could be enhanced with proper version parsing if needed
        try {
            String[] parts = modelVersion.split("\\.");
            if (parts.length >= 2) {
                int major = Integer.parseInt(parts[0]);
                int minor = Integer.parseInt(parts[1]);

                if (major > 4) {
                    return true;
                }