} else {
                    result = evaluator.evaluate(value);
                }
            }
            if (null == result && configuration.getChildCount() == 0) {
                value = configuration.getAttribute("default-value");
                if (null != value && !value.isEmpty()) {
                    if (evaluator instanceof TypeAwareExpressionEvaluator) {

            final ExpressionEvaluator evaluator,
            final ClassRealm realm,
            final ConfigurationListener listener)
            throws ComponentConfigurationException {
        try {
            ClassRealmConverter.pushContextRealm(realm);

            this.configureComponent(component, configuration, evaluator, (ClassLoader) realm, listener);
        } finally {

        XmlNode toXml(PlexusConfiguration config, ExpressionEvaluator evaluator) throws ExpressionEvaluationException {
            List<XmlNode> children = new ArrayList<>();
            for (PlexusConfiguration c : config.getChildren()) {
                children.add(toXml(c, evaluator));
            }
            String name = config.getName();
            Object value = evaluator.evaluate(config.getValue());

  there, we need to do several things to add capability to the default
  configuration of plexus. This document will detail those changes.

Container Enhancements

* ExpressionEvaluator

  Currently, the expression evaluator used to resolve configuration values
  is the DefaultExpressionEvaluator, which is a local variable within the
  implementation of the BasicComponentConfigurator. This ExpressionEvaluator

import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.resolve.constants.evaluate.CompileTimeType
import org.jetbrains.kotlin.resolve.constants.evaluate.evalBinaryOp
import org.jetbrains.kotlin.resolve.constants.evaluate.evalUnaryOp
import org.jetbrains.kotlin.types.ConstantValueKind

/**

        assertNull(ee.evaluate("${rootDirectory}"));
    }

    @Test
    void testRootDirectoryWithNull() throws Exception {
        ExpressionEvaluator ee = createExpressionEvaluator(createDefaultProject(), new Properties());
        Exception e = assertThrows(Exception.class, () -> ee.evaluate("${session.rootDirectory}"));

/**
 * Evaluator for plugin parameters expressions. Content surrounded by <code>${</code> and <code>}</code> is evaluated.
 * Recognized values are:
 * <table border="1">
 * <caption>Expression matrix</caption>
 * <tr><th>expression</th>                     <th></th>               <th>evaluation result</th></tr>

import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.BindingContext

@OptIn(KtAnalysisNonPublicApi::class) // used in IDEA K1 evaluator
@Suppress("unused")
fun KtAnalysisSession.getInlineFunctionAnalyzer(analyzeOnlyReifiedInlineFunctions: Boolean): InlineFunctionAnalyzer {
    require(this is KtFe10AnalysisSession) {

        Object value = ee.evaluate("${" + key + "}");

        assertEquals(checkValue, value);
    }

    @Test
    void testBasedirExtractionWithMissingProject() throws Exception {
        ExpressionEvaluator ee = createExpressionEvaluator(null, null, new Properties());

        Object value = ee.evaluate("${basedir}");

/**
 * Evaluator for plugin parameters expressions. Content surrounded by <code>${</code> and <code>}</code> is evaluated.
 * Recognized values are:
 * <table border="1">
 * <caption>Expression matrix</caption>
 * <tr><th>expression</th>                     <th></th>               <th>evaluation result</th></tr>