})
	if err != nil {
		t.Fatal(err)
	}

	testCases := map[string]struct {
		exts           []pkix.Extension
		expectedIDs    []string
		expectedErrMsg string
	}{
		"Empty extension list": {
			exts:           []pkix.Extension{},
			expectedIDs:    nil,
			expectedErrMsg: "the SAN extension does not exist",
		},
		"Extensions without SAN": {
			exts: []pkix.Extension{

            expectedIds << cs.id.module
            conflict = handler.registerCandidate(
                candidate(capability, cs)
            )
        }

        then:
        def actualIds = []
        conflict.withParticipatingModules {
            actualIds << it
        }

        actualIds == expectedIds
    }

			}
			if err != nil {
				return
			}
			if len(tc.expectedIDs) != len(got) {
				t.Fatalf("expected id %d, got %d", len(tc.expectedIDs), len(got))
			}
			for i := range got {
				if !reflect.DeepEqual(tc.expectedIDs[i], got[i]) {
					t.Fatalf("expected id at position %d: %+v, got: %+v", i, tc.expectedIDs[i], got[i])
				}
			}
		})
	}
}

func TestAddEntries(t *testing.T) {

			if !apiequality.Semantic.DeepEqual(tc.newEPS, tc.expectedEPS) {
				t.Errorf("Expected %+v\nGot: %+v", tc.expectedEPS, tc.newEPS)
			}
		})
	}
}

func Test_dropTopologyOnV1(t *testing.T) {
	testcases := []struct {
		name        string
		v1Request   bool
		newEPS      *discovery.EndpointSlice
		originalEPS *discovery.EndpointSlice
		expectedEPS *discovery.EndpointSlice
	}{
		{

			compareGraphs(test.expectNodes, actualNodes, test.expectEdges, actualEdges, t)
		})
	}
}

func TestToDOTGraphObj(t *testing.T) {
	tests := []struct {
		name        string
		uidToNode   map[types.UID]*node
		uids        []types.UID
		expectNodes []*dotVertex
		expectEdges []dotEdge
	}{
		{
			name: "simple",
			uidToNode: map[types.UID]*node{

		newConditions  []v1.NamespaceCondition
		startingStatus *v1.NamespaceStatus

		expecteds []v1.NamespaceCondition
	}{
		{
			name: "leave unknown",

			newConditions: []v1.NamespaceCondition{},
			startingStatus: &v1.NamespaceStatus{
				Conditions: []v1.NamespaceCondition{
					{Type: "unknown", Status: v1.ConditionTrue},
				},
			},
			expecteds: []v1.NamespaceCondition{
				{Type: "unknown", Status: v1.ConditionTrue},

			for caseIndex, expectedPos := range expectedPositions {
				actualPosition := v.fset.PositionFor(ident.Pos(), true)
				errorOccured := false
				if expectedPos.Line != actualPosition.Line {
					fmt.Fprintf(&errorMessage, "wrong line number for ident %s: expected: %d got: %d\n", ident.Name, expectedPos.Line, actualPosition.Line)
					errorOccured = true
				}
				if expectedPos.Column != actualPosition.Column {

	})
	testCases := []struct {
		name        string
		wasmPlugins []*model.WasmPluginWrapper
		names       []string
		expectedECs []*core.TypedExtensionConfig
	}{
		{
			name:        "empty",
			wasmPlugins: []*model.WasmPluginWrapper{},
			names:       []string{someAuthNFilter.Name},
			expectedECs: []*core.TypedExtensionConfig{},
		},
		{
			name: "authn",
			wasmPlugins: []*model.WasmPluginWrapper{

		ss                            *apps.StatefulSet
		oldSS                         *apps.StatefulSet
		expectedSS                    *apps.StatefulSet
	}{
		{
			name:       "set minReadySeconds, no update",
			ss:         generateStatefulSetWithMinReadySeconds(10),
			oldSS:      generateStatefulSetWithMinReadySeconds(20),
			expectedSS: generateStatefulSetWithMinReadySeconds(10),
		},
		{

	name              string
	vol               *v1.Volume
	expecteds         []expectedCommand
	isExpectedFailure bool
}, mounter volume.Mounter) []error {
	expecteds := scenario.expecteds
	allErrs := []error{}

	// Construct combined outputs from expected commands
	var fakeOutputs []fakeexec.FakeAction
	var fcmd fakeexec.FakeCmd
	for _, expected := range expecteds {
		expected := expected
		if expected.cmd[1] == "clone" {