@Override
        public RelativePath getRelativePath() {
            return relativePath;
        }

        @Override
        @Deprecated
        public int getMode() {
            DeprecationLogger.deprecateMethod(FileTreeElement.class, "getMode()")
                .replaceWith("getPermissions()")
                .willBeRemovedInGradle9()
                .withUpgradeGuideSection(8, "unix_file_permissions_deprecated")

    public NativePlatformBackedStat(PosixFiles posixFiles) {
        this.posixFiles = posixFiles;
    }

    @Override
    public int getUnixMode(File f) {
        return posixFiles.getMode(f, true);
    }

/**
 * Represents a maven plugin runtime
 *
 * @since 4.0.0
 */
@Experimental
public interface Plugin {

    @Nonnull
    org.apache.maven.api.model.Plugin getModel();

    @Nonnull
    PluginDescriptor getDescriptor();

    @Nonnull
    List<Lifecycle> getLifecycles();

    @Nonnull
    ClassLoader getClassLoader();

    @Nonnull
    Artifact getArtifact();

     * This is needed to determine if also implicit capabilities need to enter conflict detection.
     */
    boolean hasSeenCapability(Capability capability);

    interface Candidate {
        NodeState getNode();
        Capability getCapability();
        Collection<NodeState> getImplicitCapabilityProviders();
    }

    interface ResolutionDetails extends ConflictResolutionResult {

 * expressions.
 *
 * @since 4.0.0
 */
@Experimental
public interface MojoExecution {

    @Nonnull
    Plugin getPlugin();

    @Nonnull
    PluginExecution getModel();

    @Nonnull
    MojoDescriptor getDescriptor();

    @Nonnull
    String getExecutionId();

    @Nonnull
    String getGoal();

    @Nonnull
    String getLifecyclePhase();

                ${javaSourceCompatibility(targetVersion, JavaVersion.VERSION_1_5)}
            }

        """

        when:
        def ideaProject = withConnection { connection -> connection.getModel(IdeaProject) }

        then:
        ideaProject.javaLanguageSettings.languageLevel == JavaVersion.VERSION_1_7
        ideaProject.modules.find { it.name == 'root' }.javaLanguageSettings == null

    }

    public DefaultLockOptions useCrossVersionImplementation() {
        crossVersion = true;
        return this;
    }

    @Override
    public FileLockManager.LockMode getMode() {
        return mode;
    }

    @Override
    public boolean isUseCrossVersionImplementation() {
        return crossVersion;
    }

    @Override

        rootProject.name = "root"
        include 'api', 'impl', 'contrib:api', 'contrib:impl'"""

        when:

        IdeaProject project = withConnection { connection -> connection.getModel(IdeaProject.class) }

        then:
        def allNames = project.modules*.name
        allNames.unique().size() == 6

        IdeaModule impl = project.modules.find { it.name == 'root-impl' }

			err := resource.UnmarshalTo(&clientConfig)
			if err != nil {
				return nil, nil, fmt.Errorf("could not unmarshal ClientConfig: %w", err)
			}
			meta, err := model.ParseMetadata(clientConfig.GetNode().GetMetadata())
			if err != nil {
				return nil, nil, fmt.Errorf("could not parse node metadata: %w", err)
			}
			if s.Namespace != "" && meta.Namespace != s.Namespace {
				continue
			}

            }
        } catch (InternalBuildActionFailureException e) {
            throw new BuildActionFailureException("The supplied build action failed with an exception.", e.getCause());
        }
        return result.getModel();
    }

    @SuppressWarnings("deprecation")
    protected <T> BuildResult<T> execute(InternalBuildActionAdapter<T> buildActionAdapter, InternalCancellationToken cancellationTokenAdapter, BuildParameters operationParameters) {