}
			pbranch := positive
			if pk.i == 1 {
				pbranch = negative
			}
			ft.checkpoint()
			// Assume branch p->b is taken.
			addBranchRestrictions(ft, p, pbranch)
			// Check if any outgoing branch is unreachable based on the above condition.
			parent := b
			for j, bbranch := range [...]branch{positive, negative} {
				ft.checkpoint()
				// Try to update relationship b->child, and check if the contradiction occurs.

	GetAllocatableDevices() ResourceDeviceInstances

	// ShouldResetExtendedResourceCapacity returns whether the extended resources should be reset or not,
	// depending on the checkpoint file availability. Absence of the checkpoint file strongly indicates
	// the node has been recreated.
	ShouldResetExtendedResourceCapacity() bool

  string init_node_name = 2;

  // Path to the directory where checkpoint files are saved. This directoy is
  // not expected to be persistent (usually a temporary directory). When
  // fetching the restore op (see `restore_node_name`), this value is provided
  // to the "file_prefix" tensor to identify the checkpoint directory.
  string checkpoint_dir = 5;

  // Find path to variables to be restored in export directory.
  const string variables_directory =
      io::JoinPath(export_dir, kSavedModelVariablesDirectory);
  // Check for saver checkpoints in v2 format. Models exported in the checkpoint
  // v2 format will have a variables.index file. The corresponding
  // variables are stored in the variables.data-?????-of-????? files.
  const string variables_index_path = io::JoinPath(

	testPaths := map[string]string{
		"/attach/{podNamespace}/{podID}/{containerName}":       "proxy",
		"/attach/{podNamespace}/{podID}/{uid}/{containerName}": "proxy",
		"/checkpoint/{podNamespace}/{podID}/{containerName}":   "checkpoint",
		"/configz": "proxy",
		"/containerLogs/{podNamespace}/{podID}/{containerName}": "proxy",
		"/debug/flags/v":                                     "proxy",

			claimInfo.addPodReference(pod.UID)

			// Checkpoint to ensure all claims we plan to prepare are tracked.
			// If something goes wrong and the newly referenced pod gets
			// deleted without a successful prepare call, we will catch
			// that in the reconcile loop and take the appropriate action.
			if err := m.cache.syncToCheckpoint(); err != nil {
				return fmt.Errorf("failed to checkpoint claimInfo state: %w", err)
			}

	KubeletPluginsDirSELinuxLabel            = "system_u:object_r:container_file_t:s0"
	KubeletContainersSharedSELinuxLabel      = "system_u:object_r:container_file_t:s0"
	DefaultKubeletCheckpointsDirName         = "checkpoints"

      SaveVariablesToCheckpoint(*checkpoint_prefix, *module_op_ref);
  EXPECT_TRUE(variable_shared_names.ok());
  EXPECT_THAT(*variable_shared_names, IsEmpty());

  // Verify that the checkpoint doesn't exist.
  BundleReader bundle_reader(env_, *checkpoint_prefix);
  EXPECT_THAT(bundle_reader.status(), Not(IsOk()));
}

TEST_F(SaveVariablesToCheckpointTest,

 * limitations under the License.
 */
package org.gradle.launcher.daemon.testing

/**
 * Represents a particular expected registry state, and optionally a series of
 * actions to perform when the checkpoint is reached.
 */
class DaemonsStateCheckpoint {

    final DaemonsState expectedState
    private final Runnable[] actions

    DaemonsStateCheckpoint(DaemonsState expectedState, Runnable... actions) {

  AbstractTensorPtr tensor(ctx->CreateStringScalar(s));
  if (tensor.get() == nullptr) {
    return errors::Internal(
        "Failed to create scalar string tensor for checkpoint restore");
  }

  out->reset(ctx->CreateLocalHandle(tensor.get()));
  return Status();
}

// Creates a Rank 1 string tensorhandle containing a single string `s`