Projenize dahil etmek için `from starlette.staticfiles import StaticFiles` kullanabilirsiniz.

    **FastAPI**, geliştiricilere kolaylık sağlamak amacıyla `starlette.staticfiles`'ı `fastapi.staticfiles` olarak sağlar. Ancak `StaticFiles` sınıfı aslında doğrudan Starlette'den gelir.

### Bağlama (Mounting) Nedir?

			wantException: true,
		},
		{ // case 6: new --revision argument
			args:           strings.Split("--revision canary", " "),
			expectedString: "NAME     CLUSTER     CDS     LDS     EDS     RDS     ECDS     ISTIOD",
			revision:       "canary",
		},
		{ // case 7: supplying type that doesn't select pods should fail
			args:          strings.Split("serviceaccount/sleep", " "),
			wantException: true,

package org.gradle.internal.snapshot.impl;

import org.gradle.internal.isolation.Isolatable;
import org.gradle.internal.snapshot.ValueSnapshot;

import javax.annotation.Nullable;

/**
 * An isolated immutable scalar value. Should only be used for immutable JVM provided or core Gradle types.
 *
 * @param <T> the type of the value
 */

			webhook:     revisionCanonicalWebhook,
			tagName:     "canary",
			whURL:       "",
			whSVC:       "istiod-revision",
			whCA:        "ca",
			numWebhooks: 2,
		},
		{
			name:        "webhook-pointing-to-url",
			webhook:     revisionCanonicalWebhookRemote,
			tagName:     "canary",
			whURL:       remoteInjectionURL,
			whSVC:       "",
			whCA:        "ca",

        output.contains("plugin name: windows 10")
        output.contains("script input: OperatingSystem 'platforms.windows'")
        output.contains("script name: windows 10")
    }

    def "rule can target scalar property of managed element as input"() {
        when:
        buildScript '''
            @Managed
            interface Platform {
                String getName()
                void setName(String name)

  AbstractTensorPtr tensor(ctx->CreateStringScalar(abs_path));
  if (tensor.get() == nullptr) {
    return absl::InternalError(absl::StrCat(
        "Failed to create scalar string tensor for Asset at path ", abs_path));
  }

  ImmediateTensorHandlePtr handle(ctx->CreateLocalHandle(tensor.get()));
  output->reset(new Asset(std::move(handle)));
  return Status();
}

@UnsupportedWithConfigurationCache(because = "software model")
class UnmanagedCollectionPropertyIntegrationTest extends AbstractIntegrationSpec {

    def "managed type can have unmanaged properties of collection type with types that are not scalar types"() {
        given:
        buildScript """

        class Widget {
            String name
        }

        @Managed
        interface Container {
            @Unmanaged

 * of {@link org.gradle.model.internal.manage.schema.extract.ScalarTypes scalar types}, where scalar types is either one of the supported immutable JDK types above or an enumeration.
 * <p>
 * Properties of any other type must have their getter annotated with {@link Unmanaged}.

		},
		{
			execClientConfig: cannedResponseMap,
			args:             strings.Split("--timeout 2s --revision canary virtualservice foo.default", " "),
			wantException:    false,
		},
		{
			execClientConfig: distributionTrackingDisabledResponseMap,
			args:             strings.Split("--timeout 2s --revision canary virtualservice foo.default", " "),
			wantException:    true,

  }

 public:
  bool UseMlir() const { return strcmp(std::get<0>(GetParam()), "mlir") == 0; }
  bool UseFunction() const { return std::get<2>(GetParam()); }
};

// Checks that inputs[0] is a scalar.
Status TestScalarShape(AbstractContext* ctx,
                       absl::Span<AbstractTensorHandle* const> inputs,
                       absl::Span<AbstractTensorHandle*> outputs) {
  PartialTensorShape shape;