// 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

  for i in "${!all_selected_nodes[@]}"; do
    node_name="${all_selected_nodes[$i]}"
    node_dir="${report_dir}/${node_name}"
    mkdir -p "${node_dir}"
    if [[ "${i}" -lt "${#linux_nodes_selected_for_logs[@]}" ]]; then
      # Save logs in the background. This speeds up things when there are
      # many nodes.
      save-logs "${node_name}" "${node_dir}" "${node_logfiles_all}" "${node_systemd_services}" &
    else

        _ * componentState.metadata >> componentMetadata

        def variant = Stub(ResolvedGraphVariant)
        variant.nodeId >> componentId

        def component = Stub(DependencyGraphComponent)
        _ * component.resultId >> componentId
        _ * component.selectionReason >> reason
        _ * component.resolveState >> componentState

					},
					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)

			expected: "1s",
		},
		{
			testName: "cluster",
			key:      "cluster",
			option:   option.Cluster("fake"),
			expected: "fake",
		},
		{
			testName: "nodeID",
			key:      "nodeID",
			option:   option.NodeID("fake"),
			expected: "fake",
		},
		{
			testName: "region",
			key:      "region",
			option:   option.Region("fake"),
			expected: "fake",
		},
		{
			testName: "zone",

      if (e->IsControlEdge() || !reachable_nodes[e->dst()->id()]) continue;

      auto const& pair = visited.insert(e->dst());
      if (pair.second) {
        int node_id = e->dst()->id();
        Node* last_output_node = p.second;
        if (output_nodes.find(node_id) != output_nodes.end()) {
          // We reached an output node.
          if (last_output_node != nullptr) {

    private boolean removingOutgoingEdges;
    private boolean findingExternalVariants;

    public NodeState(long nodeId, ComponentState component, ResolveState resolveState, VariantGraphResolveState variant, boolean selectedByVariantAwareResolution) {
        this.nodeId = nodeId;
        this.component = component;
        this.resolveState = resolveState;
        this.variantState = variant;

			expectedMode:        proxyconfigapi.ProxyModeIPTables,
			detectLocal:         "NodeCIDR",
			expectedDetectLocal: proxyconfigapi.LocalModeNodeCIDR,
		},
		{
			name:                "override both",
			mode:                "ipvs",
			expectedMode:        proxyconfigapi.ProxyModeIPVS,
			detectLocal:         "NodeCIDR",
			expectedDetectLocal: proxyconfigapi.LocalModeNodeCIDR,
		},
	}
	for _, tc := range testCases {

}

func autoConvert_v1_CSINodeDriver_To_storage_CSINodeDriver(in *v1.CSINodeDriver, out *storage.CSINodeDriver, s conversion.Scope) error {
	out.Name = in.Name
	out.NodeID = in.NodeID
	out.TopologyKeys = *(*[]string)(unsafe.Pointer(&in.TopologyKeys))
	out.Allocatable = (*storage.VolumeNodeResources)(unsafe.Pointer(in.Allocatable))
	return nil
}

}

func autoConvert_v1beta1_CSINodeDriver_To_storage_CSINodeDriver(in *v1beta1.CSINodeDriver, out *storage.CSINodeDriver, s conversion.Scope) error {
	out.Name = in.Name
	out.NodeID = in.NodeID
	out.TopologyKeys = *(*[]string)(unsafe.Pointer(&in.TopologyKeys))
	out.Allocatable = (*storage.VolumeNodeResources)(unsafe.Pointer(in.Allocatable))
	return nil
}