// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file implements a simple printer performance benchmark:
// go test -bench=BenchmarkPrint

package printer

import (
	"bytes"
	"go/ast"
	"go/parser"
	"go/token"
	"io"
	"log"
	"os"
	"testing"
)

var (
	fileNode *ast.File
	fileSize int64

		},
	}

	outputFlags := output.NewOutputFlags(&imageTextPrintFlags{}).WithTypeSetter(outputapischeme.Scheme).WithDefaultOutput(output.TextOutput)
	printer, err := outputFlags.ToPrinter()
	if err != nil {
		t.Fatalf("can't create printer for the output format %s: %+v", output.TextOutput, err)
	}

	for _, tc := range testcases {
		t.Run(tc.name, func(t *testing.T) {

        outputContains("CWD=${workingDir.absolutePath}")
    }

    def "providers.exec provider can be wired to the task"() {
        given:
        def testScript = ShellScript.builder()
            .printText("Script output")
            .writeTo(testDirectory, "script")

        buildFile """
            def execProvider = providers.exec {
                ${cmdToExecConfig(*testScript.commandLine)}
            }

                    api 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.1'
                }

                gradlePlugin {
                    plugins {
                        'printer' { id='printer'; implementationClass='org.gradle.test.TestPlugin' }
                    }
                }

                publishing {
                    publications {
                        maven(MavenPublication) {

	"k8s.io/apimachinery/pkg/runtime/schema"
)

// TypeSetterPrinter is an implementation of ResourcePrinter wraps another printer with types set on the objects
type TypeSetterPrinter struct {
	Delegate ResourcePrinter

	Typer runtime.ObjectTyper
}

// NewTypeSetter constructs a wrapping printer with required params
func NewTypeSetter(typer runtime.ObjectTyper) *TypeSetterPrinter {
	return &TypeSetterPrinter{Typer: typer}
}

}

func BenchmarkJSONPathPrinter(b *testing.B) {
	data := newBenchmarkList()
	b.ResetTimer()
	benchmarkPrinter(b, func() ResourcePrinter {
		printer, _ := NewJSONPathPrinter("{range .items[*]}{.metadata.name}\n{end}")
		return printer
	}, data)
}

func BenchmarkYAMLPrinter(b *testing.B) {
	data := newBenchmarkList()
	b.ResetTimer()

)

// An htmlPrinter holds the state needed for printing a [Doc] as HTML.
type htmlPrinter struct {
	*Printer
	tight bool
}

// HTML returns an HTML formatting of the [Doc].
// See the [Printer] documentation for ways to customize the HTML output.
func (p *Printer) HTML(d *Doc) []byte {
	hp := &htmlPrinter{Printer: p}
	var out bytes.Buffer
	for _, x := range d.Content {
		hp.block(&out, x)
	}
	return out.Bytes()
}

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)
	if err != nil {
		t.Fatal(err)
	}
	var poutput TestStruct
	// Verify that given function runs without error.

                @TaskAction
                void printText() {
                    println getString().get()
                }
            }

            abstract class StringListTask extends DefaultTask {
                @Input
                abstract ListProperty<String> getStrings()

                @TaskAction
                void printText() {
                    println getStrings().get()
                }

	th := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: slogtest.RemoveTime})
	logger := slog.New(NewLevelHandler(slog.LevelWarn, th))
	logger.Info("not printed")
	logger.Warn("printed")

	// Output:
	// level=WARN msg=printed