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):

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 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)
	}

func CompareContent(t test.Failer, content []byte, goldenFile string) {
	t.Helper()
	golden := ReadGoldenFile(t, content, goldenFile)
	CompareBytes(t, content, golden, goldenFile)
}

// ReadGoldenFile reads the content of the golden file and fails the test if an error is encountered
func ReadGoldenFile(t test.Failer, content []byte, goldenFile string) []byte {
	t.Helper()
	RefreshGoldenFile(t, content, goldenFile)

        }
      #end
    }

      #if ( $field.type == "java.util.List" && $field.multiplicity == "*" )
        #set ( $v = $Helper.singular( ${field.name} ) )
        #set ( $scap = $Helper.capitalise( $v ) )
    public void add${scap}(${field.to} ${v}) {
        #if ( $field.to == "String" )
        update(getDelegate().with${cap}(

import org.codelibs.fess.helper.LabelTypeHelper;
import org.codelibs.fess.helper.OsddHelper;
import org.codelibs.fess.helper.PopularWordHelper;
import org.codelibs.fess.helper.QueryHelper;
import org.codelibs.fess.helper.RoleQueryHelper;
import org.codelibs.fess.helper.SearchHelper;
import org.codelibs.fess.helper.UserInfoHelper;
import org.codelibs.fess.mylasta.action.FessUserBean;

  #foreach ( $field in $allFields )
    #if ( ! $Helper.xmlFieldMetadata( $field ).attribute && ! $Helper.xmlFieldMetadata( $field ).transient )
      #set ( $fieldTagName = $Helper.xmlFieldMetadata( $field ).tagName )
      #if ( ! $fieldTagName )
        #set ( $fieldTagName = $field.name )
      #end
      #if ( $Helper.isFlatItems( $field ) )
        #set ( $fieldTagName = $Helper.singular( $fieldTagName ) )
      #end

)

func FuzzShallowCopyTrafficPolicy(f *testing.F) {
	fuzz.Fuzz(f, func(fg fuzz.Helper) {
		r := fuzz.Struct[*networking.TrafficPolicy](fg)
		copied := ShallowCopyTrafficPolicy(r)
		assert.Equal(fg.T(), r, copied)
	})
}

func FuzzShallowCopyPortTrafficPolicy(f *testing.F) {
	fuzz.Fuzz(f, func(fg fuzz.Helper) {
		r := fuzz.Struct[*networking.TrafficPolicy_PortTrafficPolicy](fg)

            rootProject.name = "root"
            include("a", "b")

            object Helper {
                fun printInfo(p: Project) {
                    println("project name = " + p.name)
                }
            }

            gradle.lifecycle.beforeProject {
                Helper.printInfo(project)
            }
        """

        when:
        succeeds("help")

        then:

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;
    }