static_range_ptq_component.Run(module_op, updated_config);
  } else if (HasQuantizationMethod(updated_config.specs(),
                                   Method::MethodCase::kWeightOnlyPtq)) {
    WeightOnlyPtqComponent weight_only_ptq_component(module_op.getContext());
    quantized_module_op =
        weight_only_ptq_component.Run(module_op, updated_config);
  } else {
    return absl::InvalidArgumentError(

        final EditBody newBody = new EditBody();
        AdminGeneralAction.updateForm(fessConfig, newBody);
        BeanUtil.copyBeanToBean(body, newBody, CopyOptions::excludeNull);
        AdminGeneralAction.updateConfig(fessConfig, newBody);
        return asJson(new ApiResponse().status(Status.OK).result());
    }

			newIndex++
		} else {
			// version may change without content changing
			oldConfig.Meta.ResourceVersion = newConfig.Meta.ResourceVersion
			if !reflect.DeepEqual(oldConfig, newConfig) {
				m.updateConfig(newConfig)
			}
			oldIndex++
			newIndex++
		}
	}

	// Detect remaining deletions
	for ; oldIndex < oldLen; oldIndex++ {
		m.deleteConfig(m.configs[oldIndex])
	}

	// Run command with an abort channel
	Run(<-chan error) error

	// Drains the envoy process.
	Drain(skipExit bool) error

	// Cleanup command for cleans up the proxy.
	Cleanup()

	// UpdateConfig writes a new config file
	UpdateConfig(config []byte) error
}

type Agent struct {
	// proxy commands
	proxy Proxy

	// channel for proxy exit notifications
	statusCh chan exitStatus

	abortCh chan error

}

func (tp TestProxy) Drain(bool) error {
	tp.blockChannel <- "unblock"
	return nil
}

func (tp TestProxy) Cleanup() {
	if tp.cleanup != nil {
		tp.cleanup()
	}
}

func (tp TestProxy) UpdateConfig(_ []byte) error {
	return nil
}

// TestStartExit starts a proxy and ensures the agent exits once the proxy exits
func TestStartExit(t *testing.T) {
	ctx := context.Background()
	done := make(chan struct{})

	err := DrainListeners(adminPort, e.Sidecar, skipExit)
	if err != nil {
		log.Infof("failed draining listeners for Envoy on port %d: %v", adminPort, err)
	}
	return err
}

func (e *envoy) UpdateConfig(config []byte) error {
	return os.WriteFile(e.ConfigPath, config, 0o666)
}

func (e *envoy) args(fname string, overrideFname string) []string {
	proxyLocalAddressType := "v4"
	if network.AllIPv6(e.NodeIPs) {