merge(artifact, infos, v, repository);
            }

            if (RELEASE.equals(version)) {
                resolve(result, infos, RELEASE);
            } else if (LATEST.equals(version)) {
                if (!resolve(result, infos, LATEST)) {
                    resolve(result, infos, RELEASE);
                }

	}
	if err == nil {
		if remountingLogStr == "" {
			klog.V(1).InfoS(volumeToMount.GenerateMsgDetailed("operationExecutor.MountVolume started", remountingLogStr), "pod", klog.KObj(volumeToMount.Pod))
		} else {
			klog.V(5).InfoS(volumeToMount.GenerateMsgDetailed("operationExecutor.MountVolume started", remountingLogStr), "pod", klog.KObj(volumeToMount.Pod))
		}
	}
}

		"/":        uint64(1 << 30),
		"/pod2-c0": uint64(1 << 15),
	}
	for name, memoryLimitOverride := range memoryLimitOverrides {
		info, found := infos[name]
		if !found {
			t.Errorf("No container defined with name %v", name)
		}
		info.Spec.Memory.Limit = memoryLimitOverride
		infos[name] = info
	}
	// any container for which cadvisor should return no stats (as might be the case for an exited init container)

                merge(artifact, infos, v, repository);
            }

            if (RELEASE.equals(version)) {
                resolve(result, infos, RELEASE);
            } else if (LATEST.equals(version)) {
                if (!resolve(result, infos, LATEST)) {
                    resolve(result, infos, RELEASE);
                }

			klog.V(5).InfoS("Setting Image ID lastUsed", "imageID", imageKey, "lastUsed", now)
			im.imageRecords[imageKey].lastUsed = now
		}

		klog.V(5).InfoS("Image ID has size", "imageID", imageKey, "size", image.Size)
		im.imageRecords[imageKey].size = image.Size

		klog.V(5).InfoS("Image ID is pinned", "imageID", imageKey, "pinned", image.Pinned)
		im.imageRecords[imageKey].pinned = image.Pinned
	}

	resources := m.getNodeAllocatable()
	allocatableResource, ok := resources[v1.ResourceMemory]
	if !ok {
		klog.V(2).InfoS("Allocatable memory value could not be determined, not setting QoS memory limits")
		return
	}
	allocatable := allocatableResource.Value()
	if allocatable == 0 {
		klog.V(2).InfoS("Allocatable memory reported as 0, might be in standalone mode, not setting QoS memory limits")
		return
	}

	klog.V(3).InfoS("Patch status for pod", "pod", klog.KObj(pod), "podUID", uid, "patch", string(patchBytes))

	if err != nil {
		klog.InfoS("Failed to update status for pod", "pod", klog.KObj(pod), "err", err)
		return
	}
	if unchanged {
		klog.V(3).InfoS("Status for pod is up-to-date", "pod", klog.KObj(pod), "statusVersion", status.version)
	} else {

		}
	}

	if len(thresholds) == 0 {
		klog.V(3).InfoS("Eviction manager: no resources are starved")
		return nil, nil
	}

	// rank the thresholds by eviction priority
	sort.Sort(byEvictionPriority(thresholds))
	thresholdToReclaim, resourceToReclaim, foundAny := getReclaimableThreshold(thresholds)
	if !foundAny {
		return nil, nil
	}

	if len(requests) == 0 {
		return maps.Values(sd.addresses), nil
	}

	var infos []model.AddressInfo
	removed := sets.String{}
	for req := range requests {
		if _, found := sd.addresses[req]; !found {
			removed.Insert(req)
		} else {
			infos = append(infos, sd.addresses[req])
		}
	}
	return infos, removed
}

func (sd *ServiceDiscovery) AdditionalPodSubscriptions(
	*model.Proxy,

		},
		{
			name: "offset1 == file size",
			infos: []lineInfo{
				{Offset: filesize, Filename: filename, Line: 2, Column: 1},
			},
			want: nil,
		},
		{
			name: "offset1 > file size",
			infos: []lineInfo{
				{Offset: filesize + 1, Filename: filename, Line: 2, Column: 1},
			},
			want: nil,
		},
		{
			name: "offset2 == file size",
			infos: []lineInfo{