File pom = getProject("it0063");

        Properties eps = new Properties();
        eps.setProperty("jre.home", new File(pom.getParentFile(), "jdk/jre").getPath());

        MavenSession session = createMavenSession(pom, eps);
        MavenProject project = session.getCurrentProject();

	public final fun getHeader (Ljava/lang/String;)Ljava/lang/String;
	public final fun getHeaders ()Lokhttp3/Headers;
	public final fun getMethod ()Ljava/lang/String;
	public final fun getPath ()Ljava/lang/String;
	public final fun getRequestLine ()Ljava/lang/String;
	public final fun getRequestUrl ()Lokhttp3/HttpUrl;
	public final fun getSequenceNumber ()I
	public final fun getTlsVersion ()Lokhttp3/TlsVersion;

    }

    private List<Artifact> toMavenArtifacts(DependencyResult dependencyResult) {
        return dependencyResult.getDependencyNodeResults().stream()
                .filter(n -> n.getArtifact().getPath() != null)
                .map(n -> RepositoryUtils.toArtifact(n.getDependency()))
                .toList();
    }

    private Map<String, ClassLoader> calcImports(

        super(id, path, timestamp);
    }

    @Override
    public String getType() {
        return KUROMOJI;
    }

    @Override
    public String getPath() {
        return path;
    }

    @Override
    public synchronized OptionalEntity<KuromojiItem> get(final long id) {
        if (kuromojiItemList == null) {
            reload(null);
        }

        }
    }

    static void forEachLeakingJavaProcess(File rootProjectDir, BiConsumer<String, String> action) {
        Pattern commandLineArgsPattern = Pattern.compile(generateLeakingProcessKillPattern(rootProjectDir.getPath()));
        forEachJavaProcess(ps(), commandLineArgsPattern, action);
    }

    private static void forEachJavaProcess(List<String> psOutput, Pattern commandLineArgsPattern, BiConsumer<String, String> action) {

        return numOfThread;
    }

    public void setNumOfThread(Integer value) {
        registerModifiedProperty("numOfThread");
        this.numOfThread = value;
    }

    public String getPaths() {
        checkSpecifiedProperty("paths");
        return convertEmptyToNull(paths);
    }

    public void setPaths(String value) {
        registerModifiedProperty("paths");
        this.paths = value;

     */
    public final void setErrorCode(final int errorCode) {
        this.errorCode = errorCode;
    }

    /**
     * @return the path
     */
    @Override
    public final String getPath() {
        return this.path;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.RequestWithPath#getFullUNCPath()
     */
    @Override
    public String getFullUNCPath() {

        super(id, path, timestamp);
    }

    @Override
    public String getType() {
        return STEMMER_OVERRIDE;
    }

    @Override
    public String getPath() {
        return path;
    }

    @Override
    public synchronized OptionalEntity<StemmerOverrideItem> get(final long id) {
        if (stemmerOverrideItemList == null) {
            reload(null);
        }

                    modelRequest.setPomFile(pomArtifact.getFile());
                } else {
                    modelRequest.setModelSource(new ArtifactModelSource(
                            pomArtifact.getPath(),
                            pomArtifact.getGroupId(),
                            pomArtifact.getArtifactId(),
                            pomArtifact.getVersion()));
                }

    }
}
```

You should prefer to use managed types when possible. 

#### Identity information 

This is an inappropriate use of lazy types:

```groovy
class Example {
    Provider<String> getPath() {
        return project.provider(() -> path)
    }
}
```

Like above, this is an immutable part of the identity of the domain object and cannot be changed.

### Properties in entirely new classes