"authentication.kubernetes.io/pod-uid":  {"uid"},
				},
			},
		},
		"extracts node name/uid": {
			info: ServiceAccountInfo{Name: "name", Namespace: "ns", NodeName: "test", NodeUID: "uid"},
			expectedUserInfo: &user.DefaultInfo{
				Name:   "system:serviceaccount:ns:name",
				Groups: []string{"system:serviceaccounts", "system:serviceaccounts:ns"},
				Extra: map[string][]string{

                options.put("xml:" + version, "xml:" + version);

                String modelId = "org.apache.maven:maven-model-builder:" + version + "-"
                        + this.getClass().getPackage().getImplementationVersion() + ":super-pom";
                InputSource inputSource = new InputSource(
                        modelId, getClass().getResource(resource).toExternalForm());

	}, nil
}

func (c *csiDriverClient) NodeGetInfo(ctx context.Context) (
	nodeID string,
	maxVolumePerNode int64,
	accessibleTopology map[string]string,
	err error) {
	klog.V(4).InfoS(log("calling NodeGetInfo rpc"))

	var getNodeInfoError error
	nodeID, maxVolumePerNode, accessibleTopology, getNodeInfoError = c.nodeGetInfoV1(ctx)
	if getNodeInfoError != nil {

  }
  return mlir::success();
}

namespace {

bool IsAssignedToLogicalDevice(const int core_id,
                               const xla::OpSharding& sharding) {
  return sharding.type() == xla::OpSharding::MAXIMAL &&
         sharding.tile_assignment_devices(0) == core_id;
}

// Returns the index of the return value of region in
// `tf_device.parallel_execute` that represents cluster func output at

	return newDurationOption("connect_timeout", value)
}

func Cluster(value string) Instance {
	return newOption("cluster", value)
}

func NodeID(value string) Instance {
	return newOption("nodeID", value)
}

func NodeType(value string) Instance {
	ntype := strings.Split(value, "~")[0]
	return newOption("nodeType", ntype)
}

func XdsType(value string) Instance {

{
  "node": {
    "id": "{{ .EnvoyConfigOpt.NodeID }}",
    "cluster": "mycluster",
    "locality": {
      "zone": "testzone"
    },
    "metadata": {
      {{ .EnvoyConfigOpt.meta_json_str }}
    }
  },
  "stats_config": {
    "use_all_default_tags": false
  },
  "admin": {
    "access_log_path": "{{.AccessLogPath}}",
    "address": {
      "socket_address": {
        "address": "0.0.0.0",

    }

    private EdgeState edge(NodeState from, boolean strict = true, String name = null, NodeState to = nextNode(), endorsing = false) {
        String moduleName = name ? name : "${from.nodeId}-${to.nodeId}"
        EdgeState edgeState = Mock()
        DependencyState dependencyState = Mock()
        DependencyMetadata dependencyMetadata = Mock()
        ModuleComponentSelector selector = Mock()

	"k8s.io/kubernetes/pkg/volume"
	"k8s.io/kubernetes/pkg/volume/util"
)

const (
	// Name of node annotation that contains JSON map of driver names to node
	annotationKeyNodeID = "csi.volume.kubernetes.io/nodeid"
)

var (
	nodeKind      = v1.SchemeGroupVersion.WithKind("Node")
	updateBackoff = wait.Backoff{
		Steps:    4,
		Duration: 10 * time.Millisecond,
		Factor:   5.0,
		Jitter:   0.1,
	}
)

	// xds client used to create a stream
	client discovery.AggregatedDiscoveryServiceClient
	conn   *grpc.ClientConn

	// Indicates if the ADSC client is closed
	closed bool

	// NodeID is the node identity sent to Pilot.
	nodeID string

	watchTime time.Time

	// initialLoad tracks the time to receive the initial configuration.
	initialLoad time.Duration

	// indicates if the initial LDS request is sent

					},
					PodPorts: []model.PodPort{
						{Name: "http", ContainerPort: 8080, Protocol: "TCP"},
						{Name: "grpc", ContainerPort: 8079, Protocol: "TCP"},
					},
				},
			},
		},
	}

	nodeID := "sidecar~1.1.1.1~id~domain"

	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {
			meta, err := mapToStruct(tt.metadata)
			if err != nil {
				t.Fatalf("failed to setup metadata: %v", err)