t.Errorf("A unexpected error has been encountered (error: %v)", err)
	}

	actualIDs, err := ExtractIDsFromSAN(san)
	if err != nil {
		t.Errorf("A unexpected error has been encountered (error: %v)", err)
	}

	if !reflect.DeepEqual(actualIDs, ids) {
		t.Errorf("Unmatched identities: before encoding: %v, after decoding %v", ids, actualIDs)
	}

	if !san.Critical {
		t.Errorf("SAN field is not critical.")
	}
}

            conflict = handler.registerCandidate(
                candidate(capability, cs)
            )
        }

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

        actualIds == expectedIds
    }

    CapabilitiesConflictHandler.Candidate candidate(CapabilityInternal cap, ComponentState co) {

     */
    private static Optional<Integer> findFirstCompleteMatch(List<String> expectedLines, List<String> actualLines) {
        for (int actualIdx = 0; actualIdx < actualLines.size(); actualIdx++) {
            if (isMatchingIndex(expectedLines, actualLines, actualIdx)) {
                return Optional.of(actualIdx);
            }
        }
        return Optional.empty();
    }

    /**

		t.Fatalf("Bad data response: %s", err)
	}

	if err := c.Quit(); err != nil {
		t.Fatalf("QUIT failed: %s", err)
	}

	bcmdbuf.Flush()
	actualcmds := cmdbuf.String()
	if client != actualcmds {
		t.Fatalf("Got:\n%s\nExpected:\n%s", actualcmds, client)
	}
}

var basicServer = `250 mx.google.com at your service
502 Unrecognized command.
250-mx.google.com at your service
250-SIZE 35651584

        for (int actualIdx = contextStartActualIdx; actualIdx <= contextEndActualIdx; actualIdx++) {
            int expectedIdx = actualIdx - matchBeginsActualIdx;

            String prefix = buildPrefix(expectedIdx, actualIdx, padding);
            context.append(prefix)
                    .append(actualLines.get(actualIdx))
                    .append('\n');

}

type InboundConnection struct {
	Src         string `json:"src"`
	OriginalDst string `json:"originalDst"`
	ActualDst   string `json:"actualDst"`
}

type OutboundConnection struct {
	Src         string `json:"src"`
	OriginalDst string `json:"originalDst"`
	ActualDst   string `json:"actualDst"`
}

type WorkloadConnection struct {
	Src         string `json:"src"`
	Dst         string `json:"dst"`

			for _, c := range wl.Connections.Inbound {
				fmt.Fprintf(w, "%v\tInbound\t%v\t%v\t%v\n", name, lookupIP(c.ActualDst), lookupIP(c.Src), c.OriginalDst)
			}
		}
		if filter.Direction != "inbound" {
			for _, c := range wl.Connections.Outbound {
				fmt.Fprintf(w, "%v\tOutbound\t%v\t%v\t%v\n", name, lookupIP(c.Src), lookupIP(c.ActualDst), lookupIP(c.OriginalDst))
			}
		}
	}
	return w.Flush()

	}

	if ips[0] != ip {
		t.Fatalf("service IP incorrect => %q, want %q", ips[0], ip)
	}

	actualIPs := service.ClusterVIPs.GetAddressesFor(clusterID)
	expectedIPs := []string{ip}
	if !reflect.DeepEqual(actualIPs, expectedIPs) {
		t.Fatalf("service IPs incorrect => %q, want %q", actualIPs, expectedIPs)
	}

	if !reflect.DeepEqual(service.Attributes.LabelSelectors, localSvc.Spec.Selector) {

		errRet := fmt.Errorf("Unable to find user DN: %w", err)
		return nil, nil, errRet
	}

	// Authenticate the user credentials.
	err = conn.Bind(lookupResult.ActualDN, password)
	if err != nil {
		errRet := fmt.Errorf("LDAP auth failed for DN %s: %w", lookupResult.ActualDN, err)
		return nil, nil, errRet
	}

	// Bind to the lookup user account again to perform group search.
	if err = l.LDAP.LookupBind(conn); err != nil {

	}
	ps.VerifyPdbStatus(t, pdbName, 0, 0, 3, 0, map[string]metav1.Time{})

	actualPDB := ps.Get(pdbName)
	condition := apimeta.FindStatusCondition(actualPDB.Status.Conditions, "ExistingTestCondition")
	if len(actualPDB.Status.Conditions) != 2 {
		t.Fatalf("Expected 2 conditions, but got %d", len(actualPDB.Status.Conditions))
	}
	if condition == nil {