AddedNamespace     *v1.Namespace
		UpdatedNamespace   *v1.Namespace
		DeletedConfigMap   *v1.ConfigMap
		UpdatedConfigMap   *v1.ConfigMap
		ExpectActions      []action
	}{
		"create new namespace": {
			AddedNamespace: newNs,
			ExpectActions:  []action{{verb: "create", name: RootCACertConfigMapName}},
		},
		"delete other configmap": {
			ExistingConfigMaps: []*v1.ConfigMap{otherConfigMap, caConfigMap},

			firstRound:  []string{"w"},
			secondRound: []string{"a"},
		},
	}
	expectations := newUIDTrackingExpectations()

	// Insert first round of keys in parallel.

	var wg sync.WaitGroup
	wg.Add(len(tracks))
	errs := make([]error, len(tracks))
	for i := range tracks {
		track := tracks[i]
		go func(errID int) {
			errs[errID] = expectations.expectFinalizersRemoved(logger, track.job, track.firstRound)
			wg.Done()
		}(i)

    ExpectAllRequestsThenReleaseAll(Lock lock, int testId, Duration timeout, WaitPrecondition previous, Collection<? extends ResourceExpectation> expectations, Executor executor) {
        super(lock, testId, timeout, expectations.size(), previous, expectations, executor);
    }

    @Override
    void doReleaseAction(BlockingHttpServer.BlockingHandler handler, int yetToBeReceived) {
        handler.releaseAll();
    }

        try {
            if (failure != null) {
                throw failure
            }
            for (ServerExpectation e in expectations) {
                e.assertMet()
            }
        } finally {
            failure = null
            expectations.clear()
        }
    }

    @Override
    protected void after() {
        stop()
        resetExpectations()
    }

        }
        // Trigger validation failures early so they can still fail the test the usual way
        try {
            allResettableExpectationsOf(invocation.instance).forEach { expectations ->
                expectations.resetExpectations()
            }
        } catch (Throwable ex) {
            expectedFailure(ex, feature)
            ignoreCleanupAssertionsOf(invocation)
            return true
        }

package org.gradle.test.fixtures;

/**
 * Allows {@link org.gradle.integtests.fixtures.ToBeFixedForConfigurationCacheExtension} to verify
 * test expectations before cleanup so they can be silenced if necessary.
 */
public interface ResettableExpectations {
    /**
     * Resets all pending expectations after verifying them.
     * Must throw when a verification fails.
     */
    void resetExpectations();

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 49539
releaseNotes:
  - |

	}
	framework.NewTest(t).
		Run(func(t framework.TestContext) {
			cases := []struct {
				name         string
				ntype        meshconfig.MeshConfig_ProxyPathNormalization_NormalizationType
				expectations []expect
			}{
				{
					"None",
					meshconfig.MeshConfig_ProxyPathNormalization_NONE,
					[]expect{
						{"/", "/"},
						{"/app#foo", "/app"},
						{"/app/", "/app/"},

		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			client, controller := newController(t, tc.cidrs)
			controller.sync()
			expectAction(t, client.Actions(), tc.actions)
		})
	}
}

func expectAction(t *testing.T, actions []k8stesting.Action, expected [][]string) {
	t.Helper()
	if len(actions) != len(expected) {

				create := action.(k8stesting.CreateAction)
				namespaceInformer.Informer().GetIndexer().Add(create.GetObject())
				return true, create.GetObject(), nil
			})

			controller.sync()

			expectAction(t, clientset.Actions(), test.actions)
			namespaces, err := controller.namespaceLister.List(labels.Everything())
			if err != nil {
				t.Errorf("unexpected error: %v", err)
			}

			got := map[string]bool{}