when:
        controller.getModel(null, modelId)

        then:
        InternalUnsupportedModelException e = thrown()
        e.cause == failure
    }

    def "cannot get model from unmanaged thread"() {
        given:
        _ * workerThreadRegistry.workerThread >> false

        when:
        controller.getModel(null, modelId)

        then:
        IllegalStateException e = thrown()

        if (modelId == null) {
            modelId = getModelId();
            source = getSource();
        }

        if (line <= 0 && column <= 0 && exception instanceof ModelParserException e) {
            line = e.getLineNumber();
            column = e.getColumnNumber();
        }

        ModelProblem problem =
                new DefaultModelProblem(message, severity, version, source, line, column, modelId, exception);

func DeletePods(ctx context.Context, kubeClient clientset.Interface, pods []*v1.Pod, recorder record.EventRecorder, nodeName, nodeUID string, daemonStore appsv1listers.DaemonSetLister) (bool, error) {
	remaining := false
	var updateErrList []error
	logger := klog.FromContext(ctx)

	if len(pods) > 0 {
		RecordNodeEvent(ctx, recorder, nodeName, nodeUID, v1.EventTypeNormal, "DeletingAllPods", fmt.Sprintf("Deleting all Pods from Node %v.", nodeName))
	}

{
  "node": {
    "id": "{{ .EnvoyConfigOpt.NodeID }}",
    "cluster": "mycluster"
  },
  "admin": {
    "access_log_path": "/dev/stdout",
    "address": {
      "socket_address": {
        "address": "0.0.0.0",
        "port_value": {{.Ports.AdminPort}}
      }
    }
  },
  "static_resources": {
    "listeners": [],
    "clusters": [
      {
        "name": "xds-grpc",
        "type": "STRICT_DNS",

     * can be used as the identifier for the super POM.
     *
     * @param modelId The identifier of the desired raw model, must not be {@code null}.
     * @return The raw model or {@code null} if the specified model id does not refer to a known model.
     */
    Model getRawModel(String modelId);

    /**

        val scheduledEntryNodeIds = mutableListOf<Int>()
        nodes.forEach { node ->
            write(node)
            val nodeId = scheduledNodeIds.size
            scheduledNodeIds[node] = nodeId
            if (node in work.entryNodes) {
                scheduledEntryNodeIds.add(nodeId)
            }
            if (node is LocalTaskNode) {
                scheduledNodeIds[node.prepareNode] = scheduledNodeIds.size

			info.Extra = make(map[string][]string)
		}
		info.Extra[NodeNameKey] = []string{sa.NodeName}
		// node UID is optional and will only be set if the node name is set
		if sa.NodeUID != "" {
			info.Extra[NodeUIDKey] = []string{sa.NodeUID}
		}
	}

	return info
}

// CredentialIDForJTI converts a given JTI string into a credential identifier for use in a
// users 'extra' info.

	return &storageapi.CSINode{
		ObjectMeta: metav1.ObjectMeta{
			Name: name,
		},
		Spec: storageapi.CSINodeSpec{
			Drivers: []storageapi.CSINodeDriver{
				{
					Name:         "valid-driver-name",
					NodeID:       "valid-node",
					TopologyKeys: []string{"company.com/zone1", "company.com/zone2"},
				},
			},
		},
	}
}

func TestCreate(t *testing.T) {
	storage, server := newStorage(t)

            def nodeMatcher = matchers[0]
            def nodeId = getTypedNodeId(plannedNode.nodeIdentity)
            assert !usedMatchers.contains(nodeMatcher)
            usedMatchers.add(nodeMatcher)
            nodeIdByTypedNodeId[nodeId] = nodeMatcher.nodeId
            expectedDependencyNodeIdsByTypedNodeId[nodeId] = nodeMatcher.dependencyNodeIds
        }

     * can be used as the identifier for the super POM.
     *
     * @param modelId The identifier of the desired raw model, must not be {@code null}.
     * @return The raw model or {@code null} if the specified model id does not refer to a known model.
     */
    @Nonnull
    Optional<Model> getRawModel(@Nonnull String modelId);

    /**