Function bodies 128 total

func (d *MockDocker) PauseContainer(ctx context.Context, id string) error {
	d.mu.Lock()
	defer d.mu.Unlock()
	state, ok := d.Containers[id]
	if !ok {
		return fmt.Errorf("container %s not found", id)
	}
	state.Paused = true
	return nil
}

func (d *MockDocker) UnpauseContainer(ctx context.Context, id string) error {
	d.mu.Lock()
	defer d.mu.Unlock()
	state, ok := d.Containers[id]
	if !ok {
		return fmt.Errorf("container %s not found", id)
	}
	state.Paused = false
	return nil
}

func (d *MockDocker) IsContainerPaused(ctx context.Context, id string) (bool, error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	state, ok := d.Containers[id]
	if !ok {
		return false, fmt.Errorf("container %s not found", id)
	}
	return state.Paused, nil
}

func (d *MockDocker) IsContainerRunning(ctx context.Context, id string) (bool, error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	state, ok := d.Containers[id]
	if !ok {
		return false, fmt.Errorf("container %s not found", id)
	}
	return state.Running, nil
}

func (d *MockDocker) UpdateMemoryLimit(ctx context.Context, id string, memoryBytes int64) error {
	d.mu.Lock()
	defer d.mu.Unlock()
	state, ok := d.Containers[id]
	if !ok {
		return fmt.Errorf("container %s not found", id)
	}
	state.MemoryLimit = memoryBytes
	return nil
}

func (d *MockDocker) CloneContainer(ctx context.Context, sourceID string, newName string) (string, error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	if _, ok := d.Containers[sourceID]; !ok {
		return "", fmt.Errorf("container %s not found", sourceID)
	}
	d.ClonedFrom = append(d.ClonedFrom, sourceID)
	d.CloneIDCounter++
	newID := fmt.Sprintf("clone%06d%06d", d.CloneIDCounter, 0)
	if newName == "" {
		newName = "clone"
	}
	d.Containers[newID] = &MockContainerState{
		Running:  true,
		Networks: []string{"bridge"},
		Name:     newName,
	}
	return newID, nil
}

func (d *MockDocker) GetContainerDiskUsage(ctx context.Context, id string) (int64, error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	state, ok := d.Containers[id]
	if !ok {
		return 0, fmt.Errorf("container %s not found", id)
	}
	return state.DiskUsage, nil
}

func (d *MockDocker) DisconnectNetwork(ctx context.Context, id string) error {
	d.mu.Lock()
	defer d.mu.Unlock()
	state, ok := d.Containers[id]
	if !ok {
		return fmt.Errorf("container %s not found", id)
	}
	state.Networks = nil
	return nil
}

func (d *MockDocker) ReconnectNetwork(ctx context.Context, id string) error {
	d.mu.Lock()
	defer d.mu.Unlock()
	state, ok := d.Containers[id]
	if !ok {
		return fmt.Errorf("container %s not found", id)
	}
	state.Networks = []string{"bridge"}
	return nil
}

func (d *MockDocker) ContainerIP(ctx context.Context, id string) (string, error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	state, ok := d.Containers[id]
	if !ok {
		return "", fmt.Errorf("container %s not found", id)
	}
	if state.IP == "" {
		return "", fmt.Errorf("no IP address for container %s", id)
	}
	return state.IP, nil
}

func (d *MockDocker) SetContainerIP(id, ip string) {
	d.mu.Lock()
	defer d.mu.Unlock()
	if state, ok := d.Containers[id]; ok {
		state.IP = ip
	}
}

func NewMockCgroup() *MockCgroup {
	return &MockCgroup{
		CgroupPaths: make(map[string]string),
		CPUUsage:    make(map[string]int64),
		MemCurrent:  make(map[string]int64),
		MemMax:      make(map[string]int64),
		IOStats:     make(map[string]*cgroup.IOStats),
		IOMax:       make(map[string]string),
		NetStats:    make(map[string]*cgroup.NetworkStats),
	}
}

func (c *MockCgroup) FindCgroupPath(dockerID string) (string, error) {
	c.mu.Lock()
	defer c.mu.Unlock()
	p, ok := c.CgroupPaths[dockerID]
	if !ok {
		return "", fmt.Errorf("cgroup path not found for container %s", dockerID)
	}
	return p, nil
}

func (c *MockCgroup) CPUUsageMicroseconds(cgroupPath string) (int64, error) {
	c.mu.Lock()
	defer c.mu.Unlock()
	v, ok := c.CPUUsage[cgroupPath]
	if !ok {
		return 0, fmt.Errorf("cpu.stat not found")
	}
	return v, nil
}

func (c *MockCgroup) MemoryCurrent(cgroupPath string) (int64, error) {
	c.mu.Lock()
	defer c.mu.Unlock()
	v, ok := c.MemCurrent[cgroupPath]
	if !ok {
		return 0, fmt.Errorf("memory.current not found")
	}
	return v, nil
}

func (c *MockCgroup) SetMemoryMax(cgroupPath string, bytes int64) error {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.MemMax[cgroupPath] = bytes
	return nil
}

func (c *MockCgroup) ReadIOStat(cgroupPath string) (*cgroup.IOStats, error) {
	c.mu.Lock()
	defer c.mu.Unlock()
	s, ok := c.IOStats[cgroupPath]
	if !ok {
		return &cgroup.IOStats{}, nil
	}
	return s, nil
}

func (c *MockCgroup) SetIOMax(cgroupPath string, deviceNum string, bps int64, iops int64) error {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.IOMax[cgroupPath] = fmt.Sprintf("%s rbps=%d wbps=%d riops=%d wiops=%d", deviceNum, bps, bps, iops, iops)
	return nil
}

func (c *MockCgroup) RemoveIOMax(cgroupPath string, deviceNum string) error {
	c.mu.Lock()
	defer c.mu.Unlock()
	delete(c.IOMax, cgroupPath)
	return nil
}

func (c *MockCgroup) ReadNetworkStats(vethName string) (*cgroup.NetworkStats, error) {
	c.mu.Lock()
	defer c.mu.Unlock()
	s, ok := c.NetStats[vethName]
	if !ok {
		return &cgroup.NetworkStats{}, nil
	}
	return s, nil
}

func NewMockEnforcement() *MockEnforcement {
	return &MockEnforcement{
		Started:  make(map[string]string),
		Enforced: make(map[string]map[model.LimitType]bool),
	}
}

func (e *MockEnforcement) StopContainer(containerID string) {
	e.mu.Lock()
	defer e.mu.Unlock()
	e.Stopped = append(e.Stopped, containerID)
	delete(e.Started, containerID)
}

func (e *MockEnforcement) IsEnforced(containerID string, lt model.LimitType) bool {
	e.mu.Lock()
	defer e.mu.Unlock()
	if m, ok := e.Enforced[containerID]; ok {
		return m[lt]
	}
	return false
}

func (e *MockEnforcement) GetEnforced(containerID string) map[model.LimitType]bool {
	e.mu.Lock()
	defer e.mu.Unlock()
	result := make(map[model.LimitType]bool)
	if m, ok := e.Enforced[containerID]; ok {
		for k, v := range m {
			result[k] = v
		}
	}
	return result
}

func (e *MockEnforcement) WasStarted(containerID string) bool {
	e.mu.Lock()
	defer e.mu.Unlock()
	_, ok := e.Started[containerID]
	return ok
}

func (e *MockEnforcement) WasStopped(containerID string) bool {
	e.mu.Lock()
	defer e.mu.Unlock()
	for _, id := range e.Stopped {
		if id == containerID {
			return true
		}
	}
	return false
}

func NewMockProxy() *MockProxy {
	return &MockProxy{
		Spending: make(map[string]int64),
		Budgets:  make(map[string]int64),
		Addrs:    make(map[string]string),
	}
}

func (p *MockProxy) RegisterContainer(containerID string, budget int64, existingSpending int64) (string, error) {
	p.mu.Lock()
	defer p.mu.Unlock()
	addr := fmt.Sprintf("127.0.0.1:%d", 10000+len(p.Addrs))
	p.Addrs[containerID] = addr
	p.Spending[containerID] = existingSpending
	p.Budgets[containerID] = budget
	return addr, nil
}