type containerAllocateResponseBuilderOption func(*containerAllocateResponseBuilder)

// withDevices sets the devices for the containerAllocateResponseBuilder
func withDevices(devices map[string]string) containerAllocateResponseBuilderOption {
	return func(b *containerAllocateResponseBuilder) {
		b.devices = devices
	}
}

	podID := "pod1"
	contID := "con1"
	devices := checkpoint.DevicesPerNUMA{0: []string{"dev1"}, 1: []string{"dev1"}}

	podDevices.insert(podID, contID, resourceName1,
		devices,
		newContainerAllocateResponse(
			withDevices(map[string]string{"/dev/r1dev1": "/dev/r1dev1", "/dev/r1dev2": "/dev/r1dev2"}),
			withMounts(map[string]string{"/home/r1lib1": "/usr/r1lib1"}),
		),
	)

	resContDevices := podDevices.getContainerDevices(podID, contID)

}

TEST(CloneConstantsForBetterClusteringTest, HostConstantPlacedOnCpu) {
  Scope root = Scope::NewRootScope().ExitOnError();
  Scope on_gpu = root.WithAssignedDevice(kGPU).WithDevice(kGPU);
  Scope on_cpu = root.WithAssignedDevice(kCPU).WithDevice(kCPU);

  Output in0 = ops::Placeholder(on_gpu.WithOpName("in0"), DT_FLOAT);
  Output in1 = ops::Placeholder(on_gpu.WithOpName("in1"), DT_FLOAT);

  return fdef_lib;
}

TEST_F(BuildXlaOpsTest, ControlDepsPreserved) {
  const char* kXlaDeviceName = "/job:worker/replica:0/task:0/device:XLA_CPU:0";
  Scope root = Scope::NewRootScope().WithDevice(kXlaDeviceName).ExitOnError();

  FunctionDefLibrary fdef_lib =
      CreateFunctionDefLibWithConstFunction("cluster_0");
  TF_ASSERT_OK(root.graph()->AddFunctionLibrary(fdef_lib));
  Node* call;

    instantiatorFactory: InstantiatorFactory,
    serviceRegistry: ServiceRegistry,
) {
    private
    val instantiator by lazy {
        instantiatorFactory
            .injectScheme()
            .withServices(injectableServicesOf(serviceRegistry))
            .instantiator()
    }

    fun schedule(scheduled: List<RegisteredFlowAction>) {
        scheduled.forEach { flowAction ->
            instantiator

            DefaultPluginManager.class,
            get(PluginRegistry.class),
            new PluginInstantiator(
                instantiatorFactory.injectScheme().withServices(this).instantiator(),
                pluginScheme.getInstantiationScheme().withServices(this).instantiator()
            ),
            pluginTarget,
            buildOperationRunner,
            userCodeApplicationContext,
            decorator,

        // TODO - dedupe logic copied from DefaultBuildServicesRegistry
        this.paramsInstantiator = instantiatorFactory.decorateScheme().withServices(services).instantiator();
        this.specInstantiator = instantiatorFactory.decorateLenientScheme().withServices(services).instantiator();
    }

    @Override

        this.isolatableFactory = isolatableFactory;
        this.leaseRegistry = leaseRegistry;
        this.paramsInstantiator = instantiatorFactory.decorateScheme().withServices(services).instantiator();
        this.specInstantiator = instantiatorFactory.decorateLenientScheme().withServices(services).instantiator();
        this.listener = listener;
        listenerManager.addListener(new ServiceCleanupListener());
    }

    }

    override fun ReadContext.newBean(generated: Boolean): Any = if (generated) {
        val services = ownerService<ServiceRegistry>()
        instantiationScheme.withServices(services).deserializationInstantiator().newInstance(beanType, Any::class.java)
    } else {
        constructorForSerialization.newInstance()
    }

    override suspend fun ReadContext.readStateOf(bean: Any) {

      if (debugging_opts.print_outputs) {
        string cpu_device = "/job:localhost/replica:0/task:0/device:CPU:0";
        ops::Print print_op(s.WithOpName("print_", oidx)
                                .WithDevice(cpu_device)
                                .WithAssignedDevice(cpu_device),
                            new_output, {new_output},
                            ops::Print::Attrs{}