return
					}
					// Use NOOP filter because the download failed.
					newExtensionConfig, err = createHTTPAllowAllFilter(extConfig.GetName())
					if err != nil {
						// If the fallback is failing, send the Nack regardless of fail_open.
						err = fmt.Errorf("failed to create allow-all filter as a fallback of %s Wasm Module: %w", extConfig.GetName(), err)
						convertErrs[i] = err
						return
					}
				}

  """Set TF_NCCL_VERSION."""
  if not is_linux():
    raise ValueError('Currently NCCL is only supported on Linux platform.')

  if 'TF_NCCL_VERSION' in environ_cp:
    return

  ask_nccl_version = (
      'Please specify the locally installed NCCL version you want to use. '
      '[Leave empty to use http://github.com/nvidia/nccl]: ')
  tf_nccl_version = get_from_env_or_user_or_default(environ_cp,

Der Befehl `uvicorn main:app` bezieht sich auf:

* `main`: die Datei `main.py` (das Python-„Modul“).
* `app`: das Objekt, das innerhalb von `main.py` mit der Zeile `app = FastAPI()` erzeugt wurde.
* `--reload`: lässt den Server nach Codeänderungen neu starten. Tun Sie das nur während der Entwicklung.

</details>

### Testen

						PortValue: uint32(listenPort),
					},
				},
			}},
			FilterChains: buildInboundFilterChains(node, push, si, mtlsPolicy),
			// the following must not be set or the client will NACK
			ListenerFilters: nil,
			UseOriginalDst:  nil,
		}
		// add extra addresses for the listener
		extrAddresses := si.Service.GetExtraAddressesForProxy(node)
		if len(extrAddresses) > 0 {

				var errorResp *google_rpc.Status
				if err != nil {
					errorResp = &google_rpc.Status{
						Code:    int32(codes.Internal),
						Message: err.Error(),
					}
				}
				// Send ACK/NACK
				con.sendRequest(&discovery.DiscoveryRequest{
					VersionInfo:   resp.VersionInfo,
					TypeUrl:       resp.TypeUrl,
					ResponseNonce: resp.Nonce,
					ErrorDetail:   errorResp,
				})
				continue

                    throw new CrawlingAccessException("Cannot get owner of the file: " + filePath, e);
                }

                if (logger.isDebugEnabled()) {
                    logger.debug("Parsing SmbFile ACL: {}", filePath);
                }
                processAccessControlEntries(responseData, file);
                final Map<String, List<String>> headerFieldMap = file.getHeaderFields();

			log.Infof("ADS: %q %s terminated with stream closed", con.peerAddr, con.conID)
			return
		}
	}
}

// ShouldRespond determines whether this request needs to be responded back. It applies the ack/nack rules as per xds protocol
// using WatchedResource for previous state and discovery request for the current state.
func ShouldRespond(w Watcher, id string, request *discovery.DiscoveryRequest) (bool, ResourceDelta) {

000000a0  00 f6 02 b3 c8 d3 ab 01  1d f2 71 86 7b f9 13 de  |..........q.{...|
000000b0  1e 39 1c e7 b5 3b b5 bb  26 33 f7 a9 3f 29 e2 8c  |.9...;..&3..?)..|
000000c0  d1 67 64 11 b4 29 be 6e  c9 cf c5 6e 41 43 41 e7  |.gd..).n...nACA.|
000000d0  43 9c 5d fb a1 b6 b3 f9  0f 4c 17 11 3c 56 0e 49  |C.]......L..<V.I|
000000e0  a0 41 8f ca 62 38 d2 83  8d 41 9b 86 5e 47 9b 79  |.A..b8...A..^G.y|

							wsro.Name, wsro.Addr, wsro.Addr+wsro.FileSize)
						t.Logf("sec %s found in these segments: ", wsro.Name)
						for _, p := range foundSegs {
							t.Logf(" %q", p.Type)
						}
						t.Logf("\nall segments: \n")
						for k, p := range elfFile.Progs {
							t.Logf("%d t=%s fl=%s st=0x%x en=0x%x\n",
								k, p.Type, p.Flags, p.Vaddr, p.Vaddr+p.Filesz)
						}
						t.Fatalf("test %s failed", test.name)

			fmt.Println("NO TESTS TO RUN")
		} else if someExcluded {
			fmt.Println("\nALL TESTS PASSED (some were excluded)")
		} else {
			fmt.Println("\nALL TESTS PASSED")
		}
	}
	if t.failed {
		xexit(1)
	}
}

func (t *tester) shouldRunTest(name string) bool {
	if t.runRx != nil {