<dst>${packaging.fess.systemd.sysctl.dir}/fess.conf</dst>
						</data>
						<!-- Adds systemd/tmpfiles.d configuration file -->
						<data>
							<type>file</type>
							<src>${project.build.directory}/generated-packaging/deb/systemd/fess.conf</src>
							<dst>${packaging.fess.tmpfilesd.dir}/fess.conf</dst>
						</data>
						<!-- Add lintian files -->

	testenv.MustHaveGoBuild(t)

	for i, test := range testObjects {
		t.Run(fmt.Sprint(i), func(t *testing.T) {
			src := "package p; " + test.src
			conf := Config{Error: func(error) {}, Importer: defaultImporter(), EnableAlias: test.alias}
			pkg, err := typecheck(src, &conf, nil)
			if err != nil {
				t.Fatalf("%s: %s", src, err)
			}

			names := strings.Split(test.obj, ".")
			if len(names) != 1 && len(names) != 2 {

		if testing.Verbose() {
			fmt.Println("\t", filename)
		}
		file, err := syntax.ParseFile(filename, nil, nil, 0)
		if err == nil {
			conf := Config{
				GoVersion: goVersion,
				Importer:  stdLibImporter,
			}
			_, err = conf.Check(filename, []*syntax.File{file}, nil)
		}

		if expectErrors {
			if err == nil {
				t.Errorf("expected errors but found none in %s", filename)
			}

	for name, id := range goIdent {
		if id.Name == name && strings.Contains(name, "_Ctype_union") {
			if def := typedef[name]; def != nil {
				id.Name = gofmt(def)
			}
		}
	}

	conf.Fprint(&buf, fset, f.AST)

	return buf.String()
}

var gofmtBuf strings.Builder

// gofmt returns the gofmt-formatted string for an AST node.
func gofmt(n interface{}) string {
	gofmtBuf.Reset()

            .create().generate()
        projectLayoutSetupRegistry.templateOperationFactory.newTemplateOperation()
            .withTemplate(templateFolder.template("build.sample.conf"))
            .withTarget(settings.target.file("../tests/build.sample.conf").asFile)
            .create().generate()
    }

    private
    fun tasksExecuted(descriptor: CompositeProjectInitDescriptor): Int {

// module version (Config.GoVersion) is used. If that version is invalid,
// allowVersion returns true.
func (check *Checker) allowVersion(at poser, v goVersion) bool {
	fileVersion := check.conf.GoVersion
	if pos := at.Pos(); pos.IsKnown() {
		fileVersion = check.versions[pos.FileBase()]
	}

	// We need asGoVersion (which calls version.Lang) below
	// because fileVersion may be the (unaltered) Config.GoVersion

	// since it affects the behavior of Universe.Lookup("any").
	//
	// This flag will eventually be removed (with Go 1.24 at the earliest).
	EnableAlias bool
}

func srcimporter_setUsesCgo(conf *Config) {
	conf.go115UsesCgo = true
}

// Info holds result type information for a type-checked package.
// Only the information for which a map is provided is collected.

                        }
                    }
                } catch (Exception e) {
                    // here we can have: IO. ZIP or Plexus Conf Ex: but we should not interfere with user intent
                }
            }
        }
        return null;
    }

        }
        final String confPath = System.getProperty(Constants.FESS_CONF_PATH);
        if (StringUtil.isNotBlank(confPath)) {
            return Paths.get(confPath, names);
        }
        return getPath("WEB-INF/", "conf", names);
    }

    public static Path getConfOrClassesPath(final String... names) {
        final Path confPath = getConfPath(names);
        if (Files.exists(confPath)) {
            return confPath;
        }

}

// objDecl type-checks the declaration of obj in its respective (file) environment.
// For the meaning of def, see Checker.definedType, in typexpr.go.
func (check *Checker) objDecl(obj Object, def *TypeName) {
	if check.conf.Trace && obj.Type() == nil {
		if check.indent == 0 {
			fmt.Println() // empty line between top-level objects for readability
		}