}
	return res, nil
}

func ReadDirOrFail(t test.Failer, filePath string, extensions ...string) []string {
	t.Helper()
	res, err := ReadDir(filePath, extensions...)
	if err != nil {
		t.Fatal(err)
	}
	return res
}

func WriteOrFail(t test.Failer, filePath string, contents []byte) {
	t.Helper()
	err := os.WriteFile(filePath, contents, os.ModePerm)
	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)

// buildScorerFunction builds volumeCapacityScorer from the scoring function shape.
func buildScorerFunction(scoringFunctionShape helper.FunctionShape) volumeCapacityScorer {
	rawScoringFunction := helper.BuildBrokenLinearFunction(scoringFunctionShape)
	f := func(requested, capacity int64) int64 {
		if capacity == 0 || requested > capacity {
			return rawScoringFunction(maxUtilization)
		}

        }
      #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}(

     */
    public static Project createProject() {
        final Project project = new Project();

        final ProjectHelper helper = ProjectHelper.getProjectHelper();
        project.addReference(MagicNames.REFID_PROJECT_HELPER, helper);
        helper.getImportStack().addElement("AntBuilder"); // import checks that stack is not empty

        project.addBuildListener(new AntLoggingAdapter());

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;

	sleq := func(t *testing.T, got []byte, want []byte) {
		t.Helper()
		if len(got) != len(want) {
			t.Fatalf("bad length got %d want %d", len(got), len(want))
		}
		for i := range got {
			if got[i] != want[i] {
				t.Fatalf("bad read at %d got %d want %d", i, got[i], want[i])
			}
		}
	}

	wf := func(t *testing.T, ws *WriteSeeker, p []byte) {
		t.Helper()
		nw, werr := ws.Write(p)
		if werr != nil {

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