Set<String> s2 =
                        computed.stream().filter(s -> !given.contains(s)).collect(Collectors.toSet());
                throw new IllegalStateException(
                        "List of phases differ in size: expected " + computed.size() + ", but received " + given.size()
                                + (s1.isEmpty() ? "" : ", missing " + s1)
                                + (s2.isEmpty() ? "" : ", unexpected " + s2));

// The slice aliases the buffer content at least until the next buffer modification,
// so immediate changes to the slice will affect the result of future reads.
func (b *Buffer) Bytes() []byte { return b.buf[b.off:] }

// AvailableBuffer returns an empty buffer with b.Available() capacity.
// This buffer is intended to be appended to and

			}
			defer configDumpFile.Close()
			configDump, err := io.ReadAll(configDumpFile)
			if err != nil {
				t.Errorf("error reading test data file: %v", err)
			}

			outFile, err := os.Open(fmt.Sprintf("testdata/secret/%s/output", tc.sds))
			if err != nil {
				t.Errorf("error opening test data output file: %v", err)
			}
			defer outFile.Close()
			expectedOut, err := io.ReadAll(outFile)

    public String getLocation() {
        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (buffer.length() > 0) {
                buffer.append(", ");
            }
            buffer.append(getSource());
        }

        if (getLineNumber() > 0) {
            if (buffer.length() > 0) {
                buffer.append(", ");
            }

    private static String toMessage(String goal, PluginDescriptor pluginDescriptor) {
        StringBuilder buffer = new StringBuilder(256);

        buffer.append("Could not find goal '").append(goal).append('\'');

        if (pluginDescriptor != null) {
            buffer.append(" in plugin ").append(pluginDescriptor.getId());

            buffer.append(" among available goals ");
            List<MojoDescriptor> mojos = pluginDescriptor.getMojos();

    }

    public String extendedToString() {
        StringBuilder buffer = new StringBuilder(256);

        buffer.append(LS).append("Artifact Metadata").append(LS).append("--------------------------");
        buffer.append(LS).append("GroupId: ").append(getGroupId());
        buffer.append(LS).append("ArtifactId: ").append(getArtifactId());
        buffer.append(LS).append("Metadata Type: ").append(getClass().getName());

        }

        buffer.append("----------").append(LS);

        int size = artifacts.size();

        buffer.append(size).append(" required artifact");

        if (size > 1) {
            buffer.append("s are");
        } else {
            buffer.append(" is");
        }

        buffer.append(" missing.").append(LS).append(LS).append("for artifact: ");

}

// sdsWriter is provided concrete implementation of SDSWriter
type sdsWriter struct {
	w      io.Writer
	output Format
}

// PrintSecretItems uses the user supplied output format to determine how to display the diffed secrets
func (w *sdsWriter) PrintSecretItems(secrets []SecretItem) error {
	var err error
	switch w.output {
	case JSON:
		err = w.printSecretItemsJSON(secrets)
	case TABULAR:

		t.Error("NewReaderSize did not detect underlying Reader")
	}
	// Does it wrap if existing buffer is too small?
	b2 := NewReaderSize(b, 2*BufSize)
	if b2 == b {
		t.Error("NewReaderSize did not enlarge buffer")
	}
}

func TestNewWriterSizeIdempotent(t *testing.T) {
	const BufSize = 1000
	b := NewWriterSize(new(bytes.Buffer), BufSize)
	// Does it recognize itself?
	b1 := NewWriterSize(b, BufSize)
	if b1 != b {

    }

    public String toString() {
        StringBuilder buffer = new StringBuilder("ManagedVersionMap (" + size() + " entries)\n");
        Iterator<String> iter = keySet().iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            buffer.append(key).append('=').append(get(key));
            if (iter.hasNext()) {
                buffer.append('\n');
            }
        }