}

func (in *TestStruct) DeepCopyObject() runtime.Object {
	panic("never called")
}

func TestJSONPrinter(t *testing.T) {
	testPrinter(t, NewTypeSetter(scheme.Scheme).ToPrinter(&JSONPrinter{}), json.Unmarshal)
}

func testPrinter(t *testing.T, printer ResourcePrinter, unmarshalFunc func(data []byte, v interface{}) error) {
	buf := bytes.NewBuffer([]byte{})

	err := printer.PrintObj(&testData, buf)

limitations under the License.
*/

package printers

import (
	"testing"

	"sigs.k8s.io/yaml"

	"k8s.io/client-go/kubernetes/scheme"
)

func TestYAMLPrinter(t *testing.T) {
	testPrinter(t, NewTypeSetter(scheme.Scheme).ToPrinter(&YAMLPrinter{}), yamlUnmarshal)
}

func yamlUnmarshal(data []byte, v interface{}) error {
	return yaml.Unmarshal(data, v)

import java.io.IOException;
import java.io.OutputStreamWriter;

/** @author Colin Decker */
public class TestWriter extends FilterWriter {

  private final TestOutputStream out;

  public TestWriter(TestOption... options) throws IOException {
    this(new TestOutputStream(ByteStreams.nullOutputStream(), options));
  }

  public TestWriter(TestOutputStream out) {
    super(new OutputStreamWriter(checkNotNull(out), UTF_8));
    this.out = out;

	Printf(format string, args ...interface{}) (n int, err error)
	Println(args ...interface{}) (n int, err error)
}

// TextPrinter implements Printer interface for generic text output
type TextPrinter struct {
}

// PrintObj is an implementation of ResourcePrinter.PrintObj that prints object
func (tp *TextPrinter) PrintObj(obj runtime.Object, writer io.Writer) error {
	_, err := fmt.Fprintf(writer, "%+v\n", obj)
	return err
}

	c kclient.ReadWriter[T]
	t test.Failer
	TestWriter[T]
}

type TestWriter[T controllers.Object] struct {
	c kclient.Writer[T]
	t test.Failer
}

func (t TestClient[T]) Get(name, namespace string) T {
	return t.c.Get(name, namespace)
}

func (t TestClient[T]) List(namespace string, selector klabels.Selector) []T {
	return t.c.List(namespace, selector)
}

func (t TestWriter[T]) Create(object T) T {
	t.t.Helper()

	// Invocation via method expression.
	check(unsafe.Pointer(reflect.Value.Pointer(testMeth(1))), unsafe.Pointer(reflect.Value.Pointer(testMeth(2))))

	// Invocation via interface.
	check(unsafe.Pointer(testInter(1).Pointer()), unsafe.Pointer(testInter(2).Pointer()))

	// Invocation via method value.
	check(unsafe.Pointer(testFunc(1)()), unsafe.Pointer(testFunc(2)()))
}

func check(p, q unsafe.Pointer) {
	a, b := *(*int)(p), *(*int)(q)

// license that can be found in the LICENSE file.

package comment

import (
	"bytes"
	"fmt"
	"sort"
	"strings"
	"unicode/utf8"
)

// A textPrinter holds the state needed for printing a Doc as plain text.
type textPrinter struct {
	*Printer
	long       strings.Builder
	prefix     string
	codePrefix string
	width      int
}

// Text returns a textual formatting of the [Doc].

// license that can be found in the LICENSE file.

package quotedprintable

import (
	"bytes"
	"io"
	"strings"
	"testing"
)

func TestWriter(t *testing.T) {
	testWriter(t, false)
}

func TestWriterBinary(t *testing.T) {
	testWriter(t, true)
}

func testWriter(t *testing.T, binary bool) {
	tests := []struct {
		in, want, wantB string
	}{
		{in: "", want: ""},
		{in: "foo bar", want: "foo bar"},

// NewWriter returns a new client for the given type.
// Any errors will call t.Fatal.
func NewWriter[T controllers.ComparableObject](t test.Failer, c kube.Client) TestWriter[T] {
	return TestWriter[T]{t: t, c: kclient.NewWriteClient[T](c)}
}

// NewDirectClient returns a new client for the given type. Reads are directly to the API server.
// Any errors will call t.Fatal.

func newTestWriter(t testing.TB) *testWriter {
	w := &testWriter{t: t}

	t.Cleanup(func() {
		w.mu.Lock()
		defer w.mu.Unlock()
		if b := w.buf.Bytes(); len(b) > 0 {
			w.t.Logf("%s", b)
			w.buf.Reset()
		}
	})

	return w
}

func (w *testWriter) Write(p []byte) (int, error) {
	w.mu.Lock()
	defer w.mu.Unlock()
	n, err := w.buf.Write(p)
	if b := w.buf.Bytes(); len(b) > 0 && b[len(b)-1] == '\n' {