Retries: &networking.HTTPRetry{
					Attempts:      2,
					RetryOn:       "some,fake,conditions",
					PerTryTimeout: durationpb.New(time.Second * 3),
				},
			},
			assertFunc: func(g *WithT, policy *envoyroute.RetryPolicy) {
				g.Expect(policy).To(Not(BeNil()))
				g.Expect(policy.RetryOn).To(Equal("some,fake,conditions"))
				g.Expect(policy.PerTryTimeout).To(Equal(durationpb.New(time.Second * 3)))

    def setup() {
        file = dir.file("some-target-file")
        lock = new OnDemandFileAccess(file, "some-lock", manager)
    }

    def "acquires shared lock to read file"() {
        def action = {} as Supplier

        when:
        lock.readFile(action)

        then:
        !file.exists()
        1 * manager.lock(file, mode(LockMode.Shared), "some-lock") >> targetLock
        1 * targetLock.readFile(action)

					},
					Sni: "some-sni.com",
				},
				err: nil,
			},
		},
		{
			name: "tls mode ISTIO_MUTUAL and H2",
			opts: &buildClusterOpts{
				mutable: newTestCluster(),
			},
			tls: &networking.ClientTLSSettings{
				Mode:            networking.ClientTLSSettings_ISTIO_MUTUAL,
				SubjectAltNames: []string{"SAN"},
				Sni:             "some-sni.com",
			},
			h2: true,

                String[] commandArray = new String[] { "some", "string" };
                List<?> commandList = Arrays.asList(commandArray);

                ProcessGroovyMethodsExecute.execute("some string");
                ProcessGroovyMethodsExecute.execute("some string", envpArray, project.file("test"));
                ProcessGroovyMethodsExecute.execute("some string", envpList, project.file("test"));

      </replaceConfiguration>

        usesEfficientSerialization(new File("some-file"), serializer, 10) == new File("some-file")
    }

    def "uses efficient serialization for Paths"() {
        expect:
        def serializer = factory.getSerializerFor(Path)
        def encoded = toBytes(Paths.get("some-file"), serializer)
        fromBytes(encoded, serializer) == Paths.get("some-file")
        encoded.length == 10
    }

In this case, it would be better to get **one extra server** and run some processes on it so that they all have **enough RAM and CPU time**.

## Réponse supplémentaire avec `model`

Vous pouvez ajouter à votre décorateur de *paramètre de chemin* un paramètre `responses`.

Il prend comme valeur un `dict` dont les clés sont des codes HTTP pour chaque réponse, comme `200`, et la valeur de ces clés sont d'autres `dict` avec des informations pour chacun d'eux.

	featuregatetesting "k8s.io/component-base/featuregate/testing"
	pkgfeatures "k8s.io/kubernetes/pkg/features"
)

func TestMakeUserNsManagerSwitch(t *testing.T) {
	// Create the manager with the feature gate enabled, to record some pods on disk.
	featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, pkgfeatures.UserNamespacesSupport, true)

	pods := []types.UID{"pod-1", "pod-2"}

	testUserNsPodsManager := &testUserNsPodsManager{

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = Some
    type = Some
  hasEscapingJumps = false
  hasJumps = false
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = []
  returnValueType = null
  valuedReturnExpressions = []