package org.gradle.sample.services;

import org.gradle.sample.api.Person;
import org.gradle.sample.shared.Helper;

public class PersonService {
    boolean checkPerson(Person person) {
        System.out.println(Helper.prettyPrint("Checking"));
        if (person.getFirstname().length() < 2) {
            return false;
        }
        return true;
    }

	return t.c.List(namespace, selector)
}

func (t TestWriter[T]) Create(object T) T {
	t.t.Helper()
	res, err := t.c.Create(object)
	if err != nil {
		t.t.Fatalf("create %v/%v: %v", object.GetNamespace(), object.GetName(), err)
	}
	return res
}

func (t TestWriter[T]) Update(object T) T {
	t.t.Helper()
	res, err := t.c.Update(object)
	if err != nil {

	}
}

// Error asserts the provided err is non-nil
func Error(t test.Failer, err error) {
	t.Helper()
	if err == nil {
		t.Fatal("expected error but got nil")
	}
}

// NoError asserts the provided err is nil
func NoError(t test.Failer, err error) {
	t.Helper()
	if err != nil {
		t.Fatalf("expected no error but got: %v", err)
	}
}

	msg := &admin.ServerInfo{}
	if err := s.adminRequest("server_info", msg); err != nil {
		return nil, err
	}

	return msg, nil
}

func (s *sidecar) InfoOrFail(t test.Failer) *admin.ServerInfo {
	t.Helper()
	info, err := s.Info()
	if err != nil {
		t.Fatal(err)
	}
	return info
}

func (s *sidecar) Config() (*admin.ConfigDump, error) {
	msg := &admin.ConfigDump{}

package org.gradle.sample.apiImpl;

import org.gradle.sample.api.Person;
import org.gradle.sample.shared.Helper;

public class PersonImpl implements Person {
    private String firstname;
    private String surname;

    public PersonImpl(String surname, String firstname) {
        this.surname = surname;
        this.firstname = firstname;
    }

    public String getFirstname() {
        return firstname;
    }

package org.gradle.sample.apiImpl;

import org.gradle.sample.api.Person;
import org.gradle.sample.shared.Helper;

public class PersonImpl implements Person {
    private String firstname;
    private String surname;

    public PersonImpl(String surname, String firstname) {
        this.surname = surname;
        this.firstname = firstname;
    }

    public String getFirstname() {
        return firstname;
    }

import (
	"strings"
	"testing"

	api "k8s.io/kubernetes/pkg/apis/core"
	utilnet "k8s.io/utils/net"
)

func TestGetLoadBalancerSourceRanges(t *testing.T) {
	checkError := func(v string) {
		t.Helper()
		annotations := make(map[string]string)
		annotations[api.AnnotationLoadBalancerSourceRangesKey] = v
		svc := api.Service{}
		svc.Annotations = annotations
		_, err := GetLoadBalancerSourceRanges(&svc)

func (a *AdsTest) ExpectError(t test.Failer) error {
	t.Helper()
	select {
	case <-time.After(a.timeout):
		t.Fatalf("did not get error in time")
	case err := <-a.error:
		return err
	}
	return nil
}

// ExpectNoResponse waits a short period of time and ensures no response is received
func (a *AdsTest) ExpectNoResponse(t test.Failer) {
	t.Helper()
	select {
	case <-time.After(time.Millisecond * 50):

func EvaluateOrFail(t test.Failer, tpl string, data any) string {
	t.Helper()
	s, err := Evaluate(tpl, data)
	if err != nil {
		t.Fatalf("tmpl.EvaluateOrFail: %v", err)
	}
	return s
}

func EvaluateFileOrFail(t test.Failer, filePath string, data any) string {
	t.Helper()
	s, err := EvaluateFile(filePath, data)
	if err != nil {
		t.Fatalf("tmpl.EvaluateFileOrFail: %v", err)
	}

	}
}

func newWatcher(t testing.TB, filename string, multi bool) mesh.Watcher {
	t.Helper()
	w, err := mesh.NewFileWatcher(filewatcher.NewWatcher(), filename, multi)
	if err != nil {
		t.Fatal(err)
	}
	return w
}

func newTempFile(t testing.TB) string {
	t.Helper()

	f, err := os.CreateTemp(t.TempDir(), t.Name())
	if err != nil {
		t.Fatal(err)
	}