diff --git a/api/maven-api-model/src/main/mdo/maven.mdo b/api/maven-api-model/src/main/mdo/maven.mdo
index d117d403fe00..851d5ab67160 100644
--- a/api/maven-api-model/src/main/mdo/maven.mdo
+++ b/api/maven-api-model/src/main/mdo/maven.mdo
@@ -2802,6 +2802,12 @@
           <type>String</type>
           <description>Specifies that this profile will be activated based on the project's packaging.</description>
         </field>
+        <field>
+          <name>condition</name>
+          <version>4.1.0+</version>
+          <type>String</type>
+          <description>The condition which must be satisfied to activate the profile.</description>
+        </field>
         <!--
         This could be included once we teach Maven to deal with multiple versions of the model
         <field>
diff --git a/maven-api-impl/src/main/java/org/apache/maven/internal/impl/model/profile/ConditionParser.java b/maven-api-impl/src/main/java/org/apache/maven/internal/impl/model/profile/ConditionParser.java
new file mode 100644
index 000000000000..5d216f95f8c0
--- /dev/null
+++ b/maven-api-impl/src/main/java/org/apache/maven/internal/impl/model/profile/ConditionParser.java
@@ -0,0 +1,429 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl.model.profile;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class ConditionParser {
+
+    public interface ExpressionFunction {
+        Object apply(List<Object> args);
+    }
+
+    private final Map<String, ExpressionFunction> functions;
+    private List<String> tokens;
+    private int current;
+
+    public ConditionParser(Map<String, ExpressionFunction> functions) {
+        this.functions = functions;
+    }
+
+    public Object parse(String expression) {
+        this.tokens = tokenize(expression);
+        this.current = 0;
+        return parseExpression();
+    }
+
+    private List<String> tokenize(String expression) {
+        List<String> tokens = new ArrayList<>();
+        StringBuilder sb = new StringBuilder();
+        char quoteType = 0;
+        boolean inPropertyAlias = false;
+        int propertyAliasDepth = 0;
+
+        for (int i = 0; i < expression.length(); i++) {
+            char c = expression.charAt(i);
+
+            if (quoteType != 0) {
+                // Inside quotes, don't process aliases
+                if (c == quoteType) {
+                    quoteType = 0;
+                    sb.append(c);
+                    tokens.add(sb.toString());
+                    sb.setLength(0);
+                } else {
+                    sb.append(c);
+                }
+                continue;
+            }
+
+            if (inPropertyAlias) {
+                if (c == '}') {
+                    propertyAliasDepth--;
+                    if (propertyAliasDepth == 0) {
+                        inPropertyAlias = false;
+                        tokens.add("property");
+                        tokens.add("(");
+                        tokens.add("'" + sb.toString() + "'");
+                        tokens.add(")");
+                        sb.setLength(0);
+                    } else {
+                        sb.append(c);
+                    }
+                } else {
+                    if (c == '$' && i + 1 < expression.length() && expression.charAt(i + 1) == '{') {
+                        propertyAliasDepth++;
+                        i++; // Skip the '{'
+                    }
+                    sb.append(c);
+                }
+                continue;
+            }
+
+            if (c == '$' && i + 1 < expression.length() && expression.charAt(i + 1) == '{') {
+                if (sb.length() > 0) {
+                    tokens.add(sb.toString());
+                    sb.setLength(0);
+                }
+                inPropertyAlias = true;
+                propertyAliasDepth = 1;
+                i++; // Skip the '{'
+                continue;
+            }
+
+            if (c == '"' || c == '\'') {
+                if (sb.length() > 0) {
+                    tokens.add(sb.toString());
+                    sb.setLength(0);
+                }
+                quoteType = c;
+                sb.append(c);
+            } else if (c == ' ' || c == '(' || c == ')' || c == ',' || c == '+' || c == '>' || c == '<' || c == '='
+                    || c == '!') {
+                if (!sb.isEmpty()) {
+                    tokens.add(sb.toString());
+                    sb.setLength(0);
+                }
+                if (c != ' ') {
+                    if ((c == '>' || c == '<' || c == '=' || c == '!')
+                            && i + 1 < expression.length()
+                            && expression.charAt(i + 1) == '=') {
+                        tokens.add(c + "=");
+                        i++; // Skip the next character
+                    } else {
+                        tokens.add(String.valueOf(c));
+                    }
+                }
+            } else {
+                sb.append(c);
+            }
+        }
+
+        if (inPropertyAlias) {
+            throw new RuntimeException("Unclosed property alias: ${");
+        }
+
+        if (!sb.isEmpty()) {
+            tokens.add(sb.toString());
+        }
+
+        return tokens;
+    }
+
+    private Object parseExpression() {
+        Object result = parseLogicalOr();
+        if (current < tokens.size()) {
+            throw new RuntimeException("Unexpected tokens after end of expression");
+        }
+        return result;
+    }
+
+    private Object parseLogicalOr() {
+        Object left = parseLogicalAnd();
+        while (current < tokens.size() && tokens.get(current).equals("||")) {
+            current++;
+            Object right = parseLogicalAnd();
+            left = (boolean) left || (boolean) right;
+        }
+        return left;
+    }
+
+    private Object parseLogicalAnd() {
+        Object left = parseComparison();
+        while (current < tokens.size() && tokens.get(current).equals("&&")) {
+            current++;
+            Object right = parseComparison();
+            left = (boolean) left && (boolean) right;
+        }
+        return left;
+    }
+
+    private Object parseComparison() {
+        Object left = parseAddSubtract();
+        while (current < tokens.size()
+                && (tokens.get(current).equals(">")
+                        || tokens.get(current).equals("<")
+                        || tokens.get(current).equals(">=")
+                        || tokens.get(current).equals("<=")
+                        || tokens.get(current).equals("==")
+                        || tokens.get(current).equals("!="))) {
+            String operator = tokens.get(current);
+            current++;
+            Object right = parseAddSubtract();
+            left = compare(left, operator, right);
+        }
+        return left;
+    }
+
+    private Object parseAddSubtract() {
+        Object left = parseMultiplyDivide();
+        while (current < tokens.size()
+                && (tokens.get(current).equals("+") || tokens.get(current).equals("-"))) {
+            String operator = tokens.get(current);
+            current++;
+            Object right = parseMultiplyDivide();
+            if (operator.equals("+")) {
+                left = add(left, right);
+            } else {
+                left = subtract(left, right);
+            }
+        }
+        return left;
+    }
+
+    private Object parseMultiplyDivide() {
+        Object left = parseUnary();
+        while (current < tokens.size()
+                && (tokens.get(current).equals("*") || tokens.get(current).equals("/"))) {
+            String operator = tokens.get(current);
+            current++;
+            Object right = parseUnary();
+            if (operator.equals("*")) {
+                left = multiply(left, right);
+            } else {
+                left = divide(left, right);
+            }
+        }
+        return left;
+    }
+
+    private Object parseUnary() {
+        if (current < tokens.size() && tokens.get(current).equals("-")) {
+            current++;
+            Object value = parseUnary();
+            return negate(value);
+        }
+        return parseTerm();
+    }
+
+    private Object parseTerm() {
+        if (current >= tokens.size()) {
+            throw new RuntimeException("Unexpected end of expression");
+        }
+
+        String token = tokens.get(current);
+        if (token.equals("(")) {
+            return parseParentheses();
+        } else if (functions.containsKey(token)) {
+            return parseFunction();
+        } else if ((token.startsWith("\"") && token.endsWith("\"")) || (token.startsWith("'") && token.endsWith("'"))) {
+            current++;
+            return token.length() > 1 ? token.substring(1, token.length() - 1) : "";
+        } else if (token.equalsIgnoreCase("true") || token.equalsIgnoreCase("false")) {
+            current++;
+            return Boolean.parseBoolean(token);
+        } else {
+            try {
+                current++;
+                return Double.parseDouble(token);
+            } catch (NumberFormatException e) {
+                // If it's not a number, treat it as a variable or unknown function
+                return parseVariableOrUnknownFunction();
+            }
+        }
+    }
+
+    private Object parseVariableOrUnknownFunction() {
+        current--; // Move back to the token we couldn't parse as a number
+        String name = tokens.get(current);
+        current++;
+
+        // Check if it's followed by an opening parenthesis, indicating a function call
+        if (current < tokens.size() && tokens.get(current).equals("(")) {
+            // It's a function call, parse it as such
+            List<Object> args = parseArgumentList();
+            if (functions.containsKey(name)) {
+                return functions.get(name).apply(args);
+            } else {
+                throw new RuntimeException("Unknown function: " + name);
+            }
+        } else {
+            // It's a variable
+            // Here you might want to handle variables differently
+            // For now, we'll throw an exception
+            throw new RuntimeException("Unknown variable: " + name);
+        }
+    }
+
+    private List<Object> parseArgumentList() {
+        List<Object> args = new ArrayList<>();
+        current++; // Skip the opening parenthesis
+        while (current < tokens.size() && !tokens.get(current).equals(")")) {
+            args.add(parseLogicalOr());
+            if (current < tokens.size() && tokens.get(current).equals(",")) {
+                current++;
+            }
+        }
+        if (current >= tokens.size() || !tokens.get(current).equals(")")) {
+            throw new RuntimeException("Mismatched parentheses: missing closing parenthesis in function call");
+        }
+        current++; // Skip the closing parenthesis
+        return args;
+    }
+
+    private Object parseFunction() {
+        String functionName = tokens.get(current);
+        current++;
+        List<Object> args = parseArgumentList();
+        return functions.get(functionName).apply(args);
+    }
+
+    private Object parseParentheses() {
+        current++; // Skip the opening parenthesis
+        Object result = parseLogicalOr();
+        if (current >= tokens.size() || !tokens.get(current).equals(")")) {
+            throw new RuntimeException("Mismatched parentheses: missing closing parenthesis");
+        }
+        current++; // Skip the closing parenthesis
+        return result;
+    }
+
+    private static Object add(Object left, Object right) {
+        if (left instanceof String || right instanceof String) {
+            return toString(left) + toString(right);
+        } else if (left instanceof Number && right instanceof Number) {
+            return ((Number) left).doubleValue() + ((Number) right).doubleValue();
+        } else {
+            throw new RuntimeException("Cannot add " + left + " and " + right);
+        }
+    }
+
+    private Object negate(Object value) {
+        if (value instanceof Number) {
+            return -((Number) value).doubleValue();
+        }
+        throw new RuntimeException("Cannot negate non-numeric value: " + value);
+    }
+
+    private static Object subtract(Object left, Object right) {
+        if (left instanceof Number && right instanceof Number) {
+            return ((Number) left).doubleValue() - ((Number) right).doubleValue();
+        } else {
+            throw new RuntimeException("Cannot subtract " + right + " from " + left);
+        }
+    }
+
+    private static Object multiply(Object left, Object right) {
+        if (left instanceof Number && right instanceof Number) {
+            return ((Number) left).doubleValue() * ((Number) right).doubleValue();
+        } else {
+            throw new RuntimeException("Cannot multiply " + left + " and " + right);
+        }
+    }
+
+    private static Object divide(Object left, Object right) {
+        if (left instanceof Number && right instanceof Number) {
+            double divisor = ((Number) right).doubleValue();
+            if (divisor == 0) {
+                throw new ArithmeticException("Division by zero");
+            }
+            return ((Number) left).doubleValue() / divisor;
+        } else {
+            throw new RuntimeException("Cannot divide " + left + " by " + right);
+        }
+    }
+
+    private static Object compare(Object left, String operator, Object right) {
+        if (left == null && right == null) {
+            return true;
+        }
+        if (left == null || right == null) {
+            if ("==".equals(operator)) {
+                return false;
+            } else if ("!=".equals(operator)) {
+                return true;
+            }
+        }
+        if (left instanceof Number && right instanceof Number) {
+            double leftVal = ((Number) left).doubleValue();
+            double rightVal = ((Number) right).doubleValue();
+            return switch (operator) {
+                case ">" -> leftVal > rightVal;
+                case "<" -> leftVal < rightVal;
+                case ">=" -> leftVal >= rightVal;
+                case "<=" -> leftVal <= rightVal;
+                case "==" -> Math.abs(leftVal - rightVal) < 1e-9;
+                case "!=" -> Math.abs(leftVal - rightVal) >= 1e-9;
+                default -> throw new IllegalStateException("Unknown operator: " + operator);
+            };
+        } else if (left instanceof String && right instanceof String) {
+            int comparison = ((String) left).compareTo((String) right);
+            return switch (operator) {
+                case ">" -> comparison > 0;
+                case "<" -> comparison < 0;
+                case ">=" -> comparison >= 0;
+                case "<=" -> comparison <= 0;
+                case "==" -> comparison == 0;
+                case "!=" -> comparison != 0;
+                default -> throw new IllegalStateException("Unknown operator: " + operator);
+            };
+        }
+        throw new RuntimeException("Cannot compare " + left + " and " + right + " with operator " + operator);
+    }
+
+    public static String toString(Object value) {
+        if (value instanceof Double) {
+            double doubleValue = (Double) value;
+            if (doubleValue == Math.floor(doubleValue)) {
+                return String.format("%.0f", doubleValue);
+            }
+        }
+        return String.valueOf(value);
+    }
+
+    public static Boolean toBoolean(Object value) {
+        if (value instanceof Boolean b) {
+            return b;
+        } else if (value instanceof String s) {
+            return !s.isBlank();
+        } else if (value instanceof Number b) {
+            return b.intValue() != 0;
+        } else {
+            return value != null;
+        }
+    }
+
+    public static double toDouble(Object value) {
+        if (value instanceof Number) {
+            return ((Number) value).doubleValue();
+        } else if (value instanceof String) {
+            try {
+                return Double.parseDouble((String) value);
+            } catch (NumberFormatException e) {
+                throw new RuntimeException("Cannot convert string to number: " + value);
+            }
+        } else if (value instanceof Boolean) {
+            return ((Boolean) value) ? 1.0 : 0.0;
+        } else {
+            throw new RuntimeException("Cannot convert to number: " + value);
+        }
+    }
+}
diff --git a/maven-api-impl/src/main/java/org/apache/maven/internal/impl/model/profile/ConditionProfileActivator.java b/maven-api-impl/src/main/java/org/apache/maven/internal/impl/model/profile/ConditionProfileActivator.java
new file mode 100644
index 000000000000..e6a39bd34a3d
--- /dev/null
+++ b/maven-api-impl/src/main/java/org/apache/maven/internal/impl/model/profile/ConditionProfileActivator.java
@@ -0,0 +1,138 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl.model.profile;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.maven.api.di.Inject;
+import org.apache.maven.api.di.Named;
+import org.apache.maven.api.di.Singleton;
+import org.apache.maven.api.model.Activation;
+import org.apache.maven.api.model.Profile;
+import org.apache.maven.api.services.BuilderProblem.Severity;
+import org.apache.maven.api.services.ModelProblem.Version;
+import org.apache.maven.api.services.ModelProblemCollector;
+import org.apache.maven.api.services.VersionParser;
+import org.apache.maven.api.services.model.ProfileActivationContext;
+import org.apache.maven.api.services.model.ProfileActivator;
+import org.apache.maven.internal.impl.model.ProfileActivationFilePathInterpolator;
+import org.apache.maven.internal.impl.model.profile.ConditionParser.ExpressionFunction;
+
+import static org.apache.maven.internal.impl.model.profile.ConditionParser.toBoolean;
+
+/**
+ * Determines profile activation based on the given condition.
+ */
+@Named("condition")
+@Singleton
+public class ConditionProfileActivator implements ProfileActivator {
+
+    final VersionParser versionParser;
+    final ProfileActivationFilePathInterpolator interpolator;
+
+    @Inject
+    public ConditionProfileActivator(VersionParser versionParser, ProfileActivationFilePathInterpolator interpolator) {
+        this.versionParser = versionParser;
+        this.interpolator = interpolator;
+    }
+
+    @Override
+    public boolean isActive(Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
+        if (profile.getActivation() == null || profile.getActivation().getCondition() == null) {
+            return false;
+        }
+        String condition = profile.getActivation().getCondition();
+        try {
+            Map<String, ExpressionFunction> functions = new HashMap<>();
+            functions.put("length", args -> args.get(0).toString().length());
+            functions.put("uppercase", args -> args.get(0).toString().toUpperCase());
+            functions.put("lowercase", args -> args.get(0).toString().toLowerCase());
+            functions.put(
+                    "concat",
+                    args -> String.join(
+                            "", args.stream().map(ConditionParser::toString).toArray(String[]::new)));
+            functions.put("substring", args -> {
+                String str = args.get(0).toString();
+                int start = ((Number) args.get(1)).intValue();
+                int end = args.size() > 2 ? ((Number) args.get(2)).intValue() : str.length();
+                return str.substring(start, end);
+            });
+            functions.put("min", args -> args.stream()
+                    .map(Comparable.class::cast)
+                    .min(Comparator.naturalOrder())
+                    .orElseThrow());
+            functions.put("max", args -> args.stream()
+                    .map(Comparable.class::cast)
+                    .max(Comparator.naturalOrder())
+                    .orElseThrow());
+            functions.put("not", args -> !(toBoolean(args.get(0))));
+            functions.put("if", args -> args.size() == 3 ? (toBoolean(args.get(0)) ? args.get(1) : args.get(2)) : null);
+            functions.put(
+                    "contains",
+                    args -> args.get(0).toString().contains(args.get(1).toString()));
+            functions.put(
+                    "matches",
+                    args -> args.get(0).toString().matches(args.get(1).toString()));
+
+            functions.put("inrange", args -> versionParser
+                    .parseVersionRange(args.get(1).toString())
+                    .contains(versionParser.parseVersion(args.get(0).toString())));
+
+            functions.put(
+                    "exists",
+                    args -> Files.exists(
+                            Paths.get(interpolator.interpolate(args.get(0).toString(), context))));
+            functions.put(
+                    "missing",
+                    args -> !Files.exists(
+                            Paths.get(interpolator.interpolate(args.get(0).toString(), context))));
+
+            functions.put("property", args -> {
+                String name = args.get(0).toString();
+                String v = context.getUserProperties().get(name);
+                if (v == null) {
+                    v = context.getProjectProperties().get(name);
+                }
+                if (v == null) {
+                    v = context.getSystemProperties().get(name);
+                }
+                return v;
+            });
+
+            return toBoolean(new ConditionParser(functions).parse(condition));
+        } catch (Exception e) {
+            problems.add(
+                    Severity.ERROR, Version.V41, "Error parsing profile activation condition: " + e.getMessage(), e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean presentInConfig(Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
+        Activation activation = profile.getActivation();
+        if (activation == null) {
+            return false;
+        }
+        return activation.getCondition() != null && !activation.getCondition().isBlank();
+    }
+}
diff --git a/maven-api-impl/src/main/java/org/apache/maven/internal/impl/model/profile/OperatingSystemProfileActivator.java b/maven-api-impl/src/main/java/org/apache/maven/internal/impl/model/profile/OperatingSystemProfileActivator.java
index a30e6f35b150..1d03e26ae2e0 100644
--- a/maven-api-impl/src/main/java/org/apache/maven/internal/impl/model/profile/OperatingSystemProfileActivator.java
+++ b/maven-api-impl/src/main/java/org/apache/maven/internal/impl/model/profile/OperatingSystemProfileActivator.java
@@ -100,7 +100,7 @@ private boolean ensureAtLeastOneNonNull(ActivationOS os) {
     }
 
     private boolean determineVersionMatch(String expectedVersion, String actualVersion) {
-        String test = expectedVersion;
+        String test = expectedVersion.toLowerCase(Locale.ENGLISH);
         boolean reverse = false;
         final boolean result;
         if (test.startsWith(REGEX_PREFIX)) {
@@ -117,7 +117,7 @@ private boolean determineVersionMatch(String expectedVersion, String actualVersi
     }
 
     private boolean determineArchMatch(String expectedArch, String actualArch) {
-        String test = expectedArch;
+        String test = expectedArch.toLowerCase(Locale.ENGLISH);
         boolean reverse = false;
 
         if (test.startsWith("!")) {
@@ -130,8 +130,8 @@ private boolean determineArchMatch(String expectedArch, String actualArch) {
         return reverse != result;
     }
 
-    private boolean determineNameMatch(String expectedName, String actualName) {
-        String test = expectedName;
+    private boolean determineNameMatch(String family, String actualName) {
+        String test = family.toLowerCase(Locale.ENGLISH);
         boolean reverse = false;
 
         if (test.startsWith("!")) {
diff --git a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/AbstractProfileActivatorTest.java b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/AbstractProfileActivatorTest.java
new file mode 100644
index 000000000000..727c30823946
--- /dev/null
+++ b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/AbstractProfileActivatorTest.java
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl.model.profile;
+
+import java.util.Properties;
+
+import org.apache.maven.api.model.Profile;
+import org.apache.maven.api.services.model.ProfileActivationContext;
+import org.apache.maven.api.services.model.ProfileActivator;
+import org.apache.maven.internal.impl.model.DefaultProfileActivationContext;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Provides common services to test {@link ProfileActivator} implementations.
+ *
+ */
+public abstract class AbstractProfileActivatorTest<T extends ProfileActivator> {
+
+    protected T activator;
+
+    @BeforeEach
+    abstract void setUp() throws Exception;
+
+    @AfterEach
+    void tearDown() throws Exception {
+        activator = null;
+    }
+
+    protected ProfileActivationContext newContext(final Properties userProperties, final Properties systemProperties) {
+        DefaultProfileActivationContext context = new DefaultProfileActivationContext();
+        return context.setUserProperties(userProperties).setSystemProperties(systemProperties);
+    }
+
+    protected void assertActivation(boolean active, Profile profile, ProfileActivationContext context) {
+        SimpleProblemCollector problems = new SimpleProblemCollector();
+
+        boolean res = activator.isActive(profile, context, problems);
+        assertEquals(0, problems.getErrors().size(), problems.getErrors().toString());
+        assertEquals(0, problems.getWarnings().size(), problems.getWarnings().toString());
+        assertEquals(active, res);
+    }
+}
diff --git a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/ConditionParserTest.java b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/ConditionParserTest.java
new file mode 100644
index 000000000000..2b9965b0d364
--- /dev/null
+++ b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/ConditionParserTest.java
@@ -0,0 +1,261 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl.model.profile;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.maven.internal.impl.model.profile.ConditionParser.ExpressionFunction;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ConditionParserTest {
+    ConditionParser parser;
+    Map<String, ExpressionFunction> functions;
+
+    @BeforeEach
+    void setUp() {
+        functions = new HashMap<>();
+        functions.put("length", args -> args.get(0).toString().length());
+        functions.put("uppercase", args -> args.get(0).toString().toUpperCase());
+        functions.put("lowercase", args -> args.get(0).toString().toLowerCase());
+        functions.put(
+                "concat",
+                args -> String.join(
+                        "", args.stream().map(ConditionParser::toString).toArray(String[]::new)));
+        functions.put("substring", args -> {
+            String str = args.get(0).toString();
+            int start = ((Number) args.get(1)).intValue();
+            int end = args.size() > 2 ? ((Number) args.get(2)).intValue() : str.length();
+            return str.substring(start, end);
+        });
+        functions.put("if", args -> args.size() == 3 ? ((Boolean) args.get(0) ? args.get(1) : args.get(2)) : null);
+        functions.put(
+                "contains", args -> args.get(0).toString().contains(args.get(1).toString()));
+        functions.put(
+                "matches", args -> args.get(0).toString().matches(args.get(1).toString()));
+
+        functions.put("add", args -> (Double) args.get(0) + (Double) args.get(1));
+        functions.put("subtract", args -> (Double) args.get(0) - (Double) args.get(1));
+        functions.put("multiply", args -> (Double) args.get(0) * (Double) args.get(1));
+        functions.put("divide", args -> {
+            if ((Double) args.get(1) == 0) {
+                throw new ArithmeticException("Division by zero");
+            }
+            return (Double) args.get(0) / (Double) args.get(1);
+        });
+
+        functions.put("property", args -> {
+            if (args.get(0).equals("os.name")) return "windows";
+            if (args.get(0).equals("os.arch")) return "amd64";
+            if (args.get(0).equals("os.version")) return "10.0";
+            return null;
+        });
+
+        parser = new ConditionParser(functions);
+    }
+
+    @Test
+    void testStringLiterals() {
+        assertEquals("Hello, World!", parser.parse("'Hello, World!'"));
+        assertEquals("Hello, World!", parser.parse("\"Hello, World!\""));
+    }
+
+    @Test
+    void testStringConcatenation() {
+        assertEquals("HelloWorld", parser.parse("'Hello' + 'World'"));
+        assertEquals("Hello123", parser.parse("'Hello' + 123"));
+    }
+
+    @Test
+    void testLengthFunction() {
+        assertEquals(13, parser.parse("length('Hello, World!')"));
+        assertEquals(5, parser.parse("length(\"Hello\")"));
+    }
+
+    @Test
+    void testCaseConversionFunctions() {
+        assertEquals("HELLO", parser.parse("uppercase('hello')"));
+        assertEquals("world", parser.parse("lowercase('WORLD')"));
+    }
+
+    @Test
+    void testConcatFunction() {
+        assertEquals("HelloWorld", parser.parse("concat('Hello', 'World')"));
+        assertEquals("The answer is 42", parser.parse("concat('The answer is ', 42)"));
+    }
+
+    @Test
+    void testSubstringFunction() {
+        assertEquals("World", parser.parse("substring('Hello, World!', 7, 12)"));
+        assertEquals("World!", parser.parse("substring('Hello, World!', 7)"));
+    }
+
+    @Test
+    void testIfFunction() {
+        assertEquals("long", parser.parse("if(length('test') > 3, 'long', 'short')"));
+        assertEquals("short", parser.parse("if(length('hi') > 3, 'long', 'short')"));
+    }
+
+    @Test
+    void testContainsFunction() {
+        assertTrue((Boolean) parser.parse("contains('Hello, World!', 'World')"));
+        assertFalse((Boolean) parser.parse("contains('Hello, World!', 'OpenAI')"));
+    }
+
+    @Test
+    void testMatchesFunction() {
+        assertTrue((Boolean) parser.parse("matches('test123', '\\w+')"));
+        assertFalse((Boolean) parser.parse("matches('test123', '\\d+')"));
+    }
+
+    @Test
+    void testComplexExpression() {
+        String expression =
+                "if(contains(lowercase('HELLO WORLD'), 'hello'), concat(uppercase('success'), '!'), 'failure')";
+        assertEquals("SUCCESS!", parser.parse(expression));
+    }
+
+    @Test
+    void testStringComparison() {
+        assertTrue((Boolean) parser.parse("'abc' != 'cdf'"));
+        assertFalse((Boolean) parser.parse("'abc' != 'abc'"));
+        assertTrue((Boolean) parser.parse("'abc' == 'abc'"));
+        assertFalse((Boolean) parser.parse("'abc' == 'cdf'"));
+    }
+
+    @Test
+    void testParenthesesMismatch() {
+        functions.put("property", args -> "foo");
+        functions.put("inrange", args -> false);
+        assertThrows(
+                RuntimeException.class,
+                () -> parser.parse(
+                        "property('os.name') == 'windows' && property('os.arch') != 'amd64') && inrange(property('os.version'), '[99,)')"),
+                "Should throw RuntimeException due to parentheses mismatch");
+
+        assertThrows(
+                RuntimeException.class,
+                () -> parser.parse(
+                        "(property('os.name') == 'windows' && property('os.arch') != 'amd64') && inrange(property('os.version'), '[99,)'"),
+                "Should throw RuntimeException due to parentheses mismatch");
+
+        // This should not throw an exception if parentheses are balanced and properties are handled correctly
+        assertDoesNotThrow(
+                () -> parser.parse(
+                        "(property('os.name') == 'windows' && property('os.arch') != 'amd64') && inrange(property('os.version'), '[99,)')"));
+    }
+
+    @Test
+    void testBasicArithmetic() {
+        assertEquals(5.0, parser.parse("2 + 3"));
+        assertEquals(10.0, parser.parse("15 - 5"));
+        assertEquals(24.0, parser.parse("6 * 4"));
+        assertEquals(3.0, parser.parse("9 / 3"));
+    }
+
+    @Test
+    void testArithmeticPrecedence() {
+        assertEquals(14.0, parser.parse("2 + 3 * 4"));
+        assertEquals(20.0, parser.parse("(2 + 3) * 4"));
+        assertEquals(11.0, parser.parse("15 - 6 + 2"));
+        assertEquals(10.0, parser.parse("10 / 2 + 2 * 2.5"));
+    }
+
+    @Test
+    void testFloatingPointArithmetic() {
+        assertEquals(5.5, parser.parse("2.2 + 3.3"));
+        assertEquals(0.1, (Double) parser.parse("3.3 - 3.2"), 1e-10);
+        assertEquals(6.25, parser.parse("2.5 * 2.5"));
+        assertEquals(2.5, parser.parse("5 / 2"));
+    }
+
+    @Test
+    void testArithmeticComparisons() {
+        assertTrue((Boolean) parser.parse("5 > 3"));
+        assertTrue((Boolean) parser.parse("3 < 5"));
+        assertTrue((Boolean) parser.parse("5 >= 5"));
+        assertTrue((Boolean) parser.parse("3 <= 3"));
+        assertTrue((Boolean) parser.parse("5 == 5"));
+        assertTrue((Boolean) parser.parse("5 != 3"));
+        assertFalse((Boolean) parser.parse("5 < 3"));
+        assertFalse((Boolean) parser.parse("3 > 5"));
+        assertFalse((Boolean) parser.parse("5 != 5"));
+    }
+
+    @Test
+    void testComplexArithmeticExpressions() {
+        assertFalse((Boolean) parser.parse("(2 + 3 * 4) > (10 + 5)"));
+        assertTrue((Boolean) parser.parse("(2 + 3 * 4) < (10 + 5)"));
+        assertTrue((Boolean) parser.parse("(10 / 2 + 3) == 8"));
+        assertTrue((Boolean) parser.parse("(10 / 2 + 3) != 9"));
+    }
+
+    @Test
+    void testArithmeticFunctions() {
+        assertEquals(5.0, parser.parse("add(2, 3)"));
+        assertEquals(2.0, parser.parse("subtract(5, 3)"));
+        assertEquals(15.0, parser.parse("multiply(3, 5)"));
+        assertEquals(2.5, parser.parse("divide(5, 2)"));
+    }
+
+    @Test
+    void testCombinedArithmeticAndLogic() {
+        assertTrue((Boolean) parser.parse("(5 > 3) && (10 / 2 == 5)"));
+        assertFalse((Boolean) parser.parse("(5 < 3) || (10 / 2 != 5)"));
+        assertTrue((Boolean) parser.parse("add(2, 3) == multiply(1, 5)"));
+    }
+
+    @Test
+    void testDivisionByZero() {
+        assertThrows(ArithmeticException.class, () -> parser.parse("5 / 0"));
+        assertThrows(ArithmeticException.class, () -> parser.parse("divide(10, 0)"));
+    }
+
+    @Test
+    void testPropertyAlias() {
+        assertTrue((Boolean) parser.parse("${os.name} == 'windows'"));
+        assertFalse((Boolean) parser.parse("${os.name} == 'linux'"));
+        assertTrue((Boolean) parser.parse("${os.arch} == 'amd64' && ${os.name} == 'windows'"));
+        assertThrows(RuntimeException.class, () -> parser.parse("${unclosed"));
+    }
+
+    @Test
+    void testNestedPropertyAlias() {
+        functions.put("property", args -> {
+            if (args.get(0).equals("project.rootDirectory")) return "/home/user/project";
+            return null;
+        });
+        functions.put("exists", args -> true); // Mock implementation
+
+        Object result = parser.parse("exists('${project.rootDirectory}/someFile.txt')");
+        assertTrue((Boolean) result);
+
+        result = parser.parse("exists('${project.rootDirectory}/${nested.property}/someFile.txt')");
+        assertTrue((Boolean) result);
+
+        assertDoesNotThrow(() -> parser.parse("property('')"));
+    }
+}
diff --git a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/ConditionProfileActivatorTest.java b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/ConditionProfileActivatorTest.java
new file mode 100644
index 000000000000..7a069e369ac0
--- /dev/null
+++ b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/ConditionProfileActivatorTest.java
@@ -0,0 +1,506 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl.model.profile;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Properties;
+
+import org.apache.maven.api.model.Activation;
+import org.apache.maven.api.model.ActivationFile;
+import org.apache.maven.api.model.Profile;
+import org.apache.maven.api.services.model.ProfileActivationContext;
+import org.apache.maven.api.services.model.RootLocator;
+import org.apache.maven.internal.impl.DefaultModelVersionParser;
+import org.apache.maven.internal.impl.DefaultVersionParser;
+import org.apache.maven.internal.impl.model.DefaultInterpolator;
+import org.apache.maven.internal.impl.model.DefaultPathTranslator;
+import org.apache.maven.internal.impl.model.DefaultProfileActivationContext;
+import org.apache.maven.internal.impl.model.ProfileActivationFilePathInterpolator;
+import org.eclipse.aether.util.version.GenericVersionScheme;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class ConditionProfileActivatorTest extends AbstractProfileActivatorTest<ConditionProfileActivator> {
+
+    @TempDir
+    Path tempDir;
+
+    @BeforeEach
+    @Override
+    void setUp() throws Exception {
+        activator = new ConditionProfileActivator(
+                new DefaultVersionParser(new DefaultModelVersionParser(new GenericVersionScheme())),
+                new ProfileActivationFilePathInterpolator(
+                        new DefaultPathTranslator(), bd -> true, new DefaultInterpolator()));
+
+        File file = new File(tempDir.resolve("file.txt").toString());
+        if (!file.createNewFile()) {
+            throw new IOException("Can't create " + file);
+        }
+    }
+
+    private Profile newProfile(String condition) {
+        Activation a = Activation.newBuilder().condition(condition).build();
+        Profile p = Profile.newBuilder().activation(a).build();
+        return p;
+    }
+
+    private Properties newJdkProperties(String javaVersion) {
+        Properties props = new Properties();
+        props.setProperty("java.version", javaVersion);
+        return props;
+    }
+
+    @Test
+    void testNullSafe() throws Exception {
+        Profile p = Profile.newInstance();
+
+        assertActivation(false, p, newContext(null, null));
+
+        p = p.withActivation(Activation.newInstance());
+
+        assertActivation(false, p, newContext(null, null));
+    }
+
+    @Test
+    void testJdkPrefix() throws Exception {
+        Profile profile = newProfile("inrange(property('java.version'), '[1.4,1.5)')");
+
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.4")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.4.2")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.4.2_09")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.4.2_09-b03")));
+
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.3")));
+
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.5")));
+    }
+
+    @Test
+    void testJdkPrefixNegated() throws Exception {
+        Profile profile = newProfile("not(inrange(property('java.version'), '[1.4,1.5)'))");
+
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4.2")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4.2_09")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4.2_09-b03")));
+
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.3")));
+
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5")));
+    }
+
+    @Test
+    void testJdkVersionRangeInclusiveBounds() throws Exception {
+        Profile profile = newProfile("inrange(${java.version}, '[1.5,1.6.1]')");
+
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4.2")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4.2_09")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4.2_09-b03")));
+
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0_09")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0_09-b03")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.1")));
+
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.6")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.6.0")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.6.0_09")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.6.0_09-b03")));
+    }
+
+    @Test
+    void testJdkVersionRangeExclusiveBounds() throws Exception {
+        Profile profile = newProfile("inrange(${java.version}, '[1.3.1,1.6)')");
+
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.3")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.3.0")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.3.0_09")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.3.0_09-b03")));
+
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.3.1")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.3.1_09")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.3.1_09-b03")));
+
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0_09")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0_09-b03")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.1")));
+
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.6")));
+    }
+
+    @Test
+    void testJdkVersionRangeInclusiveLowerBound() throws Exception {
+        Profile profile = newProfile("inrange(${java.version}, '[1.5,)')");
+
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4.2")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4.2_09")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.4.2_09-b03")));
+
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0_09")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0_09-b03")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.1")));
+
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.6")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.6.0")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.6.0_09")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.6.0_09-b03")));
+    }
+
+    @Test
+    void testJdkVersionRangeExclusiveUpperBound() throws Exception {
+        Profile profile = newProfile("inrange(${java.version}, '(,1.6)')");
+
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0_09")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.0_09-b03")));
+        assertActivation(true, profile, newContext(null, newJdkProperties("1.5.1")));
+
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.6")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.6.0")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.6.0_09")));
+        assertActivation(false, profile, newContext(null, newJdkProperties("1.6.0_09-b03")));
+    }
+
+    @Disabled
+    @Test
+    void testJdkRubbishJavaVersion() {
+        Profile profile = newProfile("inrange(${java.version}, '[1.8,)')");
+
+        assertActivationWithProblems(profile, newContext(null, newJdkProperties("Pūteketeke")), "invalid JDK version");
+        assertActivationWithProblems(profile, newContext(null, newJdkProperties("rubbish")), "invalid JDK version");
+        assertActivationWithProblems(profile, newContext(null, newJdkProperties("1.a.0_09")), "invalid JDK version");
+        assertActivationWithProblems(profile, newContext(null, newJdkProperties("1.a.2.b")), "invalid JDK version");
+    }
+
+    private void assertActivationWithProblems(
+            Profile profile, ProfileActivationContext context, String warningContains) {
+        SimpleProblemCollector problems = new SimpleProblemCollector();
+
+        assertFalse(activator.isActive(profile, context, problems));
+
+        assertEquals(0, problems.getErrors().size(), problems.getErrors().toString());
+        assertEquals(1, problems.getWarnings().size(), problems.getWarnings().toString());
+        assertTrue(
+                problems.getWarnings().get(0).contains(warningContains),
+                problems.getWarnings().toString());
+    }
+
+    private Properties newOsProperties(String osName, String osVersion, String osArch) {
+        Properties props = new Properties();
+        props.setProperty("os.name", osName);
+        props.setProperty("os.version", osVersion);
+        props.setProperty("os.arch", osArch);
+        return props;
+    }
+
+    @Test
+    void testOsVersionStringComparison() throws Exception {
+        Profile profile = newProfile("inrange(${os.version}, '[6.5.0-1014-aws,6.6)')");
+
+        assertActivation(true, profile, newContext(null, newOsProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(true, profile, newContext(null, newOsProperties("windows", "6.5.0-1014-aws", "aarch64")));
+
+        assertActivation(false, profile, newContext(null, newOsProperties("linux", "3.1.0", "amd64")));
+    }
+
+    @Test
+    void testOsVersionRegexMatching() throws Exception {
+        Profile profile = newProfile("matches(${os.version}, '.*aws')");
+
+        assertActivation(true, profile, newContext(null, newOsProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(true, profile, newContext(null, newOsProperties("windows", "6.5.0-1014-aws", "aarch64")));
+
+        assertActivation(false, profile, newContext(null, newOsProperties("linux", "3.1.0", "amd64")));
+    }
+
+    @Test
+    void testOsName() {
+        Profile profile = newProfile("${os.name} == 'windows'");
+
+        assertActivation(false, profile, newContext(null, newOsProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(true, profile, newContext(null, newOsProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    @Test
+    void testOsNegatedName() {
+        Profile profile = newProfile("${os.name} != 'windows'");
+
+        assertActivation(true, profile, newContext(null, newOsProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(false, profile, newContext(null, newOsProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    @Test
+    void testOsArch() {
+        Profile profile = newProfile("${os.arch} == 'amd64'");
+
+        assertActivation(true, profile, newContext(null, newOsProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(false, profile, newContext(null, newOsProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    @Test
+    void testOsNegatedArch() {
+        Profile profile = newProfile("${os.arch} != 'amd64'");
+
+        assertActivation(false, profile, newContext(null, newOsProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(true, profile, newContext(null, newOsProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    /*
+    @Test
+    void testOsFamily() {
+        Profile profile = newProfile(ActivationOS.newBuilder().family("windows"));
+
+        assertActivation(false, profile, newContext(null, newOsProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(true, profile, newContext(null, newOsProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    @Test
+    void testOsNegatedFamily() {
+        Profile profile = newProfile(ActivationOS.newBuilder().family("!windows"));
+
+        assertActivation(true, profile, newContext(null, newOsProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(false, profile, newContext(null, newOsProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+     */
+
+    @Test
+    void testOsAllConditions() {
+        Profile profile =
+                newProfile("${os.name} == 'windows' && ${os.arch} != 'amd64' && inrange(${os.version}, '[99,)')");
+
+        assertActivation(false, profile, newContext(null, newOsProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(false, profile, newContext(null, newOsProperties("windows", "1", "aarch64")));
+        assertActivation(false, profile, newContext(null, newOsProperties("windows", "99", "amd64")));
+        assertActivation(true, profile, newContext(null, newOsProperties("windows", "99", "aarch64")));
+    }
+
+    @Test
+    public void testOsCapitalName() {
+        Profile profile = newProfile("lowercase(${os.name}) == 'mac os x'");
+
+        assertActivation(false, profile, newContext(null, newOsProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(false, profile, newContext(null, newOsProperties("windows", "1", "aarch64")));
+        assertActivation(false, profile, newContext(null, newOsProperties("windows", "99", "amd64")));
+        assertActivation(true, profile, newContext(null, newOsProperties("Mac OS X", "14.5", "aarch64")));
+    }
+
+    private Properties newPropProperties(String key, String value) {
+        Properties props = new Properties();
+        props.setProperty(key, value);
+        return props;
+    }
+
+    @Test
+    void testPropWithNameOnly_UserProperty() throws Exception {
+        Profile profile = newProfile("${prop}");
+
+        assertActivation(true, profile, newContext(newPropProperties("prop", "value"), null));
+
+        assertActivation(false, profile, newContext(newPropProperties("prop", ""), null));
+
+        assertActivation(false, profile, newContext(newPropProperties("other", "value"), null));
+    }
+
+    @Test
+    void testPropWithNameOnly_SystemProperty() throws Exception {
+        Profile profile = newProfile("${prop}");
+
+        assertActivation(true, profile, newContext(null, newPropProperties("prop", "value")));
+
+        assertActivation(false, profile, newContext(null, newPropProperties("prop", "")));
+
+        assertActivation(false, profile, newContext(null, newPropProperties("other", "value")));
+    }
+
+    @Test
+    void testPropWithNegatedNameOnly_UserProperty() throws Exception {
+        Profile profile = newProfile("not(${prop})");
+
+        assertActivation(false, profile, newContext(newPropProperties("prop", "value"), null));
+
+        assertActivation(true, profile, newContext(newPropProperties("prop", ""), null));
+
+        assertActivation(true, profile, newContext(newPropProperties("other", "value"), null));
+    }
+
+    @Test
+    void testPropWithNegatedNameOnly_SystemProperty() throws Exception {
+        Profile profile = newProfile("not(${prop})");
+
+        assertActivation(false, profile, newContext(null, newPropProperties("prop", "value")));
+
+        assertActivation(true, profile, newContext(null, newPropProperties("prop", "")));
+
+        assertActivation(true, profile, newContext(null, newPropProperties("other", "value")));
+    }
+
+    @Test
+    void testPropWithValue_UserProperty() throws Exception {
+        Profile profile = newProfile("${prop} == 'value'");
+
+        assertActivation(true, profile, newContext(newPropProperties("prop", "value"), null));
+
+        assertActivation(false, profile, newContext(newPropProperties("prop", "other"), null));
+
+        assertActivation(false, profile, newContext(newPropProperties("prop", ""), null));
+    }
+
+    @Test
+    void testPropWithValue_SystemProperty() throws Exception {
+        Profile profile = newProfile("${prop} == 'value'");
+
+        assertActivation(true, profile, newContext(null, newPropProperties("prop", "value")));
+
+        assertActivation(false, profile, newContext(null, newPropProperties("prop", "other")));
+
+        assertActivation(false, profile, newContext(null, newPropProperties("other", "")));
+    }
+
+    @Test
+    void testPropWithNegatedValue_UserProperty() throws Exception {
+        Profile profile = newProfile("${prop} != 'value'");
+
+        assertActivation(false, profile, newContext(newPropProperties("prop", "value"), null));
+
+        assertActivation(true, profile, newContext(newPropProperties("prop", "other"), null));
+
+        assertActivation(true, profile, newContext(newPropProperties("prop", ""), null));
+    }
+
+    @Test
+    void testPropWithNegatedValue_SystemProperty() throws Exception {
+        Profile profile = newProfile("${prop} != 'value'");
+
+        assertActivation(false, profile, newContext(null, newPropProperties("prop", "value")));
+
+        assertActivation(true, profile, newContext(null, newPropProperties("prop", "other")));
+
+        assertActivation(true, profile, newContext(null, newPropProperties("other", "")));
+    }
+
+    @Test
+    void testPropWithValue_UserPropertyDominantOverSystemProperty() throws Exception {
+        Profile profile = newProfile("${prop} == 'value'");
+
+        Properties props1 = newPropProperties("prop", "value");
+        Properties props2 = newPropProperties("prop", "other");
+
+        assertActivation(true, profile, newContext(props1, props2));
+
+        assertActivation(false, profile, newContext(props2, props1));
+    }
+
+    @Test
+    @Disabled
+    void testFileRootDirectoryWithNull() {
+        IllegalStateException e = assertThrows(
+                IllegalStateException.class,
+                () -> assertActivation(false, newProfile("exists('${project.rootDirectory}')"), newFileContext(null)));
+        assertEquals(RootLocator.UNABLE_TO_FIND_ROOT_PROJECT_MESSAGE, e.getMessage());
+    }
+
+    @Test
+    void testFileRootDirectory() {
+        assertActivation(false, newProfile("exists('${project.rootDirectory}/someFile.txt')"), newFileContext());
+        assertActivation(true, newProfile("missing('${project.rootDirectory}/someFile.txt')"), newFileContext());
+        assertActivation(true, newProfile("exists('${project.rootDirectory}')"), newFileContext());
+        assertActivation(true, newProfile("exists('${project.rootDirectory}/file.txt')"), newFileContext());
+        assertActivation(false, newProfile("missing('${project.rootDirectory}')"), newFileContext());
+        assertActivation(false, newProfile("missing('${project.rootDirectory}/file.txt')"), newFileContext());
+    }
+
+    @Test
+    void testFileIsActiveNoFileWithShortBasedir() {
+        assertActivation(false, newExistsProfile(null), newFileContext());
+        assertActivation(false, newProfile("exists('someFile.txt')"), newFileContext());
+        assertActivation(false, newProfile("exists('${basedir}/someFile.txt')"), newFileContext());
+
+        assertActivation(false, newMissingProfile(null), newFileContext());
+        assertActivation(true, newProfile("missing('someFile.txt')"), newFileContext());
+        assertActivation(true, newProfile("missing('${basedir}/someFile.txt')"), newFileContext());
+    }
+
+    @Test
+    void testFileIsActiveNoFile() {
+        assertActivation(false, newExistsProfile(null), newFileContext());
+        assertActivation(false, newProfile("exists('someFile.txt')"), newFileContext());
+        assertActivation(false, newProfile("exists('${project.basedir}/someFile.txt')"), newFileContext());
+
+        assertActivation(false, newMissingProfile(null), newFileContext());
+        assertActivation(true, newProfile("missing('someFile.txt')"), newFileContext());
+        assertActivation(true, newProfile("missing('${project.basedir}/someFile.txt')"), newFileContext());
+    }
+
+    @Test
+    void testFileIsActiveExistsFileExists() {
+        assertActivation(true, newProfile("exists('file.txt')"), newFileContext());
+        assertActivation(true, newProfile("exists('${project.basedir}')"), newFileContext());
+        assertActivation(true, newProfile("exists('${project.basedir}/file.txt')"), newFileContext());
+
+        assertActivation(false, newProfile("missing('file.txt')"), newFileContext());
+        assertActivation(false, newProfile("missing('${project.basedir}')"), newFileContext());
+        assertActivation(false, newProfile("missing('${project.basedir}/file.txt')"), newFileContext());
+    }
+
+    private Profile newExistsProfile(String filePath) {
+        ActivationFile activationFile =
+                ActivationFile.newBuilder().exists(filePath).build();
+        return newProfile(activationFile);
+    }
+
+    private Profile newMissingProfile(String filePath) {
+        ActivationFile activationFile =
+                ActivationFile.newBuilder().missing(filePath).build();
+        return newProfile(activationFile);
+    }
+
+    private Profile newProfile(ActivationFile activationFile) {
+        Activation activation = Activation.newBuilder().file(activationFile).build();
+        return Profile.newBuilder().activation(activation).build();
+    }
+
+    protected ProfileActivationContext newFileContext(Path path) {
+        DefaultProfileActivationContext context = new DefaultProfileActivationContext();
+        context.setProjectDirectory(path);
+        return context;
+    }
+
+    protected ProfileActivationContext newFileContext() {
+        return newFileContext(tempDir);
+    }
+}
diff --git a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/FileProfileActivatorTest.java b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/FileProfileActivatorTest.java
new file mode 100644
index 000000000000..2d7382d0dc4e
--- /dev/null
+++ b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/FileProfileActivatorTest.java
@@ -0,0 +1,144 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl.model.profile;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+
+import org.apache.maven.api.model.Activation;
+import org.apache.maven.api.model.ActivationFile;
+import org.apache.maven.api.model.Profile;
+import org.apache.maven.api.services.model.RootLocator;
+import org.apache.maven.internal.impl.model.DefaultInterpolator;
+import org.apache.maven.internal.impl.model.DefaultPathTranslator;
+import org.apache.maven.internal.impl.model.DefaultProfileActivationContext;
+import org.apache.maven.internal.impl.model.ProfileActivationFilePathInterpolator;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * Tests {@link FileProfileActivator}.
+ *
+ */
+class FileProfileActivatorTest extends AbstractProfileActivatorTest<FileProfileActivator> {
+
+    @TempDir
+    Path tempDir;
+
+    private final DefaultProfileActivationContext context = new DefaultProfileActivationContext();
+
+    @BeforeEach
+    @Override
+    void setUp() throws Exception {
+        activator = new FileProfileActivator(new ProfileActivationFilePathInterpolator(
+                new DefaultPathTranslator(), bd -> true, new DefaultInterpolator()));
+
+        context.setProjectDirectory(tempDir);
+
+        File file = new File(tempDir.resolve("file.txt").toString());
+        if (!file.createNewFile()) {
+            throw new IOException("Can't create " + file);
+        }
+    }
+
+    @Test
+    void testRootDirectoryWithNull() {
+        context.setProjectDirectory(null);
+
+        IllegalStateException e = assertThrows(
+                IllegalStateException.class,
+                () -> assertActivation(false, newExistsProfile("${project.rootDirectory}"), context));
+        assertEquals(RootLocator.UNABLE_TO_FIND_ROOT_PROJECT_MESSAGE, e.getMessage());
+    }
+
+    @Test
+    void testRootDirectory() {
+        assertActivation(false, newExistsProfile("${project.rootDirectory}/someFile.txt"), context);
+        assertActivation(true, newMissingProfile("${project.rootDirectory}/someFile.txt"), context);
+        assertActivation(true, newExistsProfile("${project.rootDirectory}"), context);
+        assertActivation(true, newExistsProfile("${project.rootDirectory}/" + "file.txt"), context);
+        assertActivation(false, newMissingProfile("${project.rootDirectory}"), context);
+        assertActivation(false, newMissingProfile("${project.rootDirectory}/" + "file.txt"), context);
+    }
+
+    @Test
+    void testIsActiveNoFileWithShortBasedir() {
+        assertActivation(false, newExistsProfile(null), context);
+        assertActivation(false, newExistsProfile("someFile.txt"), context);
+        assertActivation(false, newExistsProfile("${basedir}/someFile.txt"), context);
+
+        assertActivation(false, newMissingProfile(null), context);
+        assertActivation(true, newMissingProfile("someFile.txt"), context);
+        assertActivation(true, newMissingProfile("${basedir}/someFile.txt"), context);
+    }
+
+    @Test
+    void testIsActiveNoFile() {
+        assertActivation(false, newExistsProfile(null), context);
+        assertActivation(false, newExistsProfile("someFile.txt"), context);
+        assertActivation(false, newExistsProfile("${project.basedir}/someFile.txt"), context);
+
+        assertActivation(false, newMissingProfile(null), context);
+        assertActivation(true, newMissingProfile("someFile.txt"), context);
+        assertActivation(true, newMissingProfile("${project.basedir}/someFile.txt"), context);
+    }
+
+    @Test
+    void testIsActiveExistsFileExists() {
+        assertActivation(true, newExistsProfile("file.txt"), context);
+        assertActivation(true, newExistsProfile("${project.basedir}"), context);
+        assertActivation(true, newExistsProfile("${project.basedir}/" + "file.txt"), context);
+
+        assertActivation(false, newMissingProfile("file.txt"), context);
+        assertActivation(false, newMissingProfile("${project.basedir}"), context);
+        assertActivation(false, newMissingProfile("${project.basedir}/" + "file.txt"), context);
+    }
+
+    @Test
+    void testIsActiveExistsLeavesFileUnchanged() {
+        Profile profile = newExistsProfile("file.txt");
+        assertEquals("file.txt", profile.getActivation().getFile().getExists());
+
+        assertActivation(true, profile, context);
+
+        assertEquals("file.txt", profile.getActivation().getFile().getExists());
+    }
+
+    private Profile newExistsProfile(String filePath) {
+        ActivationFile activationFile =
+                ActivationFile.newBuilder().exists(filePath).build();
+        return newProfile(activationFile);
+    }
+
+    private Profile newMissingProfile(String filePath) {
+        ActivationFile activationFile =
+                ActivationFile.newBuilder().missing(filePath).build();
+        return newProfile(activationFile);
+    }
+
+    private Profile newProfile(ActivationFile activationFile) {
+        Activation activation = Activation.newBuilder().file(activationFile).build();
+        return Profile.newBuilder().activation(activation).build();
+    }
+}
diff --git a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/JdkVersionProfileActivatorTest.java b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/JdkVersionProfileActivatorTest.java
new file mode 100644
index 000000000000..1bee37f5e667
--- /dev/null
+++ b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/JdkVersionProfileActivatorTest.java
@@ -0,0 +1,198 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl.model.profile;
+
+import java.util.Properties;
+
+import org.apache.maven.api.model.Activation;
+import org.apache.maven.api.model.Profile;
+import org.apache.maven.api.services.model.ProfileActivationContext;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests {@link JdkVersionProfileActivator}.
+ *
+ */
+class JdkVersionProfileActivatorTest extends AbstractProfileActivatorTest<JdkVersionProfileActivator> {
+
+    @Override
+    @BeforeEach
+    void setUp() throws Exception {
+        activator = new JdkVersionProfileActivator();
+    }
+
+    private Profile newProfile(String jdkVersion) {
+        Activation a = Activation.newBuilder().jdk(jdkVersion).build();
+
+        Profile p = Profile.newBuilder().activation(a).build();
+
+        return p;
+    }
+
+    private Properties newProperties(String javaVersion) {
+        Properties props = new Properties();
+        props.setProperty("java.version", javaVersion);
+        return props;
+    }
+
+    @Test
+    void testNullSafe() throws Exception {
+        Profile p = Profile.newInstance();
+
+        assertActivation(false, p, newContext(null, null));
+
+        p = p.withActivation(Activation.newInstance());
+
+        assertActivation(false, p, newContext(null, null));
+    }
+
+    @Test
+    void testPrefix() throws Exception {
+        Profile profile = newProfile("1.4");
+
+        assertActivation(true, profile, newContext(null, newProperties("1.4")));
+        assertActivation(true, profile, newContext(null, newProperties("1.4.2")));
+        assertActivation(true, profile, newContext(null, newProperties("1.4.2_09")));
+        assertActivation(true, profile, newContext(null, newProperties("1.4.2_09-b03")));
+
+        assertActivation(false, profile, newContext(null, newProperties("1.3")));
+
+        assertActivation(false, profile, newContext(null, newProperties("1.5")));
+    }
+
+    @Test
+    void testPrefixNegated() throws Exception {
+        Profile profile = newProfile("!1.4");
+
+        assertActivation(false, profile, newContext(null, newProperties("1.4")));
+        assertActivation(false, profile, newContext(null, newProperties("1.4.2")));
+        assertActivation(false, profile, newContext(null, newProperties("1.4.2_09")));
+        assertActivation(false, profile, newContext(null, newProperties("1.4.2_09-b03")));
+
+        assertActivation(true, profile, newContext(null, newProperties("1.3")));
+
+        assertActivation(true, profile, newContext(null, newProperties("1.5")));
+    }
+
+    @Test
+    void testVersionRangeInclusiveBounds() throws Exception {
+        Profile profile = newProfile("[1.5,1.6]");
+
+        assertActivation(false, profile, newContext(null, newProperties("1.4")));
+        assertActivation(false, profile, newContext(null, newProperties("1.4.2")));
+        assertActivation(false, profile, newContext(null, newProperties("1.4.2_09")));
+        assertActivation(false, profile, newContext(null, newProperties("1.4.2_09-b03")));
+
+        assertActivation(true, profile, newContext(null, newProperties("1.5")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0_09")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0_09-b03")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.1")));
+
+        assertActivation(true, profile, newContext(null, newProperties("1.6")));
+        assertActivation(true, profile, newContext(null, newProperties("1.6.0")));
+        assertActivation(true, profile, newContext(null, newProperties("1.6.0_09")));
+        assertActivation(true, profile, newContext(null, newProperties("1.6.0_09-b03")));
+    }
+
+    @Test
+    void testVersionRangeExclusiveBounds() throws Exception {
+        Profile profile = newProfile("(1.3,1.6)");
+
+        assertActivation(false, profile, newContext(null, newProperties("1.3")));
+        assertActivation(false, profile, newContext(null, newProperties("1.3.0")));
+        assertActivation(false, profile, newContext(null, newProperties("1.3.0_09")));
+        assertActivation(false, profile, newContext(null, newProperties("1.3.0_09-b03")));
+
+        assertActivation(true, profile, newContext(null, newProperties("1.3.1")));
+        assertActivation(true, profile, newContext(null, newProperties("1.3.1_09")));
+        assertActivation(true, profile, newContext(null, newProperties("1.3.1_09-b03")));
+
+        assertActivation(true, profile, newContext(null, newProperties("1.5")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0_09")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0_09-b03")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.1")));
+
+        assertActivation(false, profile, newContext(null, newProperties("1.6")));
+    }
+
+    @Test
+    void testVersionRangeInclusiveLowerBound() throws Exception {
+        Profile profile = newProfile("[1.5,)");
+
+        assertActivation(false, profile, newContext(null, newProperties("1.4")));
+        assertActivation(false, profile, newContext(null, newProperties("1.4.2")));
+        assertActivation(false, profile, newContext(null, newProperties("1.4.2_09")));
+        assertActivation(false, profile, newContext(null, newProperties("1.4.2_09-b03")));
+
+        assertActivation(true, profile, newContext(null, newProperties("1.5")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0_09")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0_09-b03")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.1")));
+
+        assertActivation(true, profile, newContext(null, newProperties("1.6")));
+        assertActivation(true, profile, newContext(null, newProperties("1.6.0")));
+        assertActivation(true, profile, newContext(null, newProperties("1.6.0_09")));
+        assertActivation(true, profile, newContext(null, newProperties("1.6.0_09-b03")));
+    }
+
+    @Test
+    void testVersionRangeExclusiveUpperBound() throws Exception {
+        Profile profile = newProfile("(,1.6)");
+
+        assertActivation(true, profile, newContext(null, newProperties("1.5")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0_09")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.0_09-b03")));
+        assertActivation(true, profile, newContext(null, newProperties("1.5.1")));
+
+        assertActivation(false, profile, newContext(null, newProperties("1.6")));
+        assertActivation(false, profile, newContext(null, newProperties("1.6.0")));
+        assertActivation(false, profile, newContext(null, newProperties("1.6.0_09")));
+        assertActivation(false, profile, newContext(null, newProperties("1.6.0_09-b03")));
+    }
+
+    @Test
+    void testRubbishJavaVersion() {
+        Profile profile = newProfile("[1.8,)");
+
+        assertActivationWithProblems(profile, newContext(null, newProperties("Pūteketeke")), "invalid JDK version");
+        assertActivationWithProblems(profile, newContext(null, newProperties("rubbish")), "invalid JDK version");
+        assertActivationWithProblems(profile, newContext(null, newProperties("1.a.0_09")), "invalid JDK version");
+        assertActivationWithProblems(profile, newContext(null, newProperties("1.a.2.b")), "invalid JDK version");
+    }
+
+    private void assertActivationWithProblems(
+            Profile profile, ProfileActivationContext context, String warningContains) {
+        SimpleProblemCollector problems = new SimpleProblemCollector();
+
+        assertFalse(activator.isActive(profile, context, problems));
+
+        assertEquals(0, problems.getErrors().size());
+        assertEquals(1, problems.getWarnings().size());
+        assertTrue(problems.getWarnings().get(0).contains(warningContains));
+    }
+}
diff --git a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/OperatingSystemProfileActivatorTest.java b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/OperatingSystemProfileActivatorTest.java
new file mode 100644
index 000000000000..486a9472706b
--- /dev/null
+++ b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/OperatingSystemProfileActivatorTest.java
@@ -0,0 +1,152 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl.model.profile;
+
+import java.util.Properties;
+
+import org.apache.maven.api.model.Activation;
+import org.apache.maven.api.model.ActivationOS;
+import org.apache.maven.api.model.Profile;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests {@link OperatingSystemProfileActivator}.
+ *
+ */
+class OperatingSystemProfileActivatorTest extends AbstractProfileActivatorTest<OperatingSystemProfileActivator> {
+
+    @Override
+    @BeforeEach
+    void setUp() throws Exception {
+        activator = new OperatingSystemProfileActivator();
+    }
+
+    private Profile newProfile(ActivationOS.Builder activationBuilder) {
+        Activation a = Activation.newBuilder().os(activationBuilder.build()).build();
+
+        Profile p = Profile.newBuilder().activation(a).build();
+
+        return p;
+    }
+
+    private Properties newProperties(String osName, String osVersion, String osArch) {
+        Properties props = new Properties();
+        props.setProperty("os.name", osName);
+        props.setProperty("os.version", osVersion);
+        props.setProperty("os.arch", osArch);
+        return props;
+    }
+
+    @Test
+    void testVersionStringComparison() throws Exception {
+        Profile profile = newProfile(ActivationOS.newBuilder().version("6.5.0-1014-aws"));
+
+        assertActivation(true, profile, newContext(null, newProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(true, profile, newContext(null, newProperties("windows", "6.5.0-1014-aws", "aarch64")));
+
+        assertActivation(false, profile, newContext(null, newProperties("linux", "3.1.0", "amd64")));
+    }
+
+    @Test
+    void testVersionRegexMatching() throws Exception {
+        Profile profile = newProfile(ActivationOS.newBuilder().version("regex:.*aws"));
+
+        assertActivation(true, profile, newContext(null, newProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(true, profile, newContext(null, newProperties("windows", "6.5.0-1014-aws", "aarch64")));
+
+        assertActivation(false, profile, newContext(null, newProperties("linux", "3.1.0", "amd64")));
+    }
+
+    @Test
+    void testName() {
+        Profile profile = newProfile(ActivationOS.newBuilder().name("windows"));
+
+        assertActivation(false, profile, newContext(null, newProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(true, profile, newContext(null, newProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    @Test
+    void testNegatedName() {
+        Profile profile = newProfile(ActivationOS.newBuilder().name("!windows"));
+
+        assertActivation(true, profile, newContext(null, newProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(false, profile, newContext(null, newProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    @Test
+    void testArch() {
+        Profile profile = newProfile(ActivationOS.newBuilder().arch("amd64"));
+
+        assertActivation(true, profile, newContext(null, newProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(false, profile, newContext(null, newProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    @Test
+    void testNegatedArch() {
+        Profile profile = newProfile(ActivationOS.newBuilder().arch("!amd64"));
+
+        assertActivation(false, profile, newContext(null, newProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(true, profile, newContext(null, newProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    @Test
+    void testFamily() {
+        Profile profile = newProfile(ActivationOS.newBuilder().family("windows"));
+
+        assertActivation(false, profile, newContext(null, newProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(true, profile, newContext(null, newProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    @Test
+    void testNegatedFamily() {
+        Profile profile = newProfile(ActivationOS.newBuilder().family("!windows"));
+
+        assertActivation(true, profile, newContext(null, newProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(false, profile, newContext(null, newProperties("windows", "6.5.0-1014-aws", "aarch64")));
+    }
+
+    @Test
+    void testAllOsConditions() {
+        Profile profile = newProfile(ActivationOS.newBuilder()
+                .family("windows")
+                .name("windows")
+                .arch("aarch64")
+                .version("99"));
+
+        assertActivation(false, profile, newContext(null, newProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(false, profile, newContext(null, newProperties("windows", "1", "aarch64")));
+        assertActivation(false, profile, newContext(null, newProperties("windows", "99", "amd64")));
+        assertActivation(true, profile, newContext(null, newProperties("windows", "99", "aarch64")));
+    }
+
+    @Test
+    public void testCapitalOsName() {
+        Profile profile = newProfile(ActivationOS.newBuilder()
+                .family("Mac")
+                .name("Mac OS X")
+                .arch("aarch64")
+                .version("14.5"));
+
+        assertActivation(false, profile, newContext(null, newProperties("linux", "6.5.0-1014-aws", "amd64")));
+        assertActivation(false, profile, newContext(null, newProperties("windows", "1", "aarch64")));
+        assertActivation(false, profile, newContext(null, newProperties("windows", "99", "amd64")));
+        assertActivation(true, profile, newContext(null, newProperties("Mac OS X", "14.5", "aarch64")));
+    }
+}
diff --git a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/PropertyProfileActivatorTest.java b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/PropertyProfileActivatorTest.java
new file mode 100644
index 000000000000..bdeffff13d5a
--- /dev/null
+++ b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/PropertyProfileActivatorTest.java
@@ -0,0 +1,168 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl.model.profile;
+
+import java.util.Properties;
+
+import org.apache.maven.api.model.Activation;
+import org.apache.maven.api.model.ActivationProperty;
+import org.apache.maven.api.model.Profile;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests {@link PropertyProfileActivator}.
+ *
+ */
+class PropertyProfileActivatorTest extends AbstractProfileActivatorTest<PropertyProfileActivator> {
+
+    @BeforeEach
+    @Override
+    void setUp() throws Exception {
+        activator = new PropertyProfileActivator();
+    }
+
+    private Profile newProfile(String key, String value) {
+        ActivationProperty ap =
+                ActivationProperty.newBuilder().name(key).value(value).build();
+
+        Activation a = Activation.newBuilder().property(ap).build();
+
+        Profile p = Profile.newBuilder().activation(a).build();
+
+        return p;
+    }
+
+    private Properties newProperties(String key, String value) {
+        Properties props = new Properties();
+        props.setProperty(key, value);
+        return props;
+    }
+
+    @Test
+    void testNullSafe() throws Exception {
+        Profile p = Profile.newInstance();
+
+        assertActivation(false, p, newContext(null, null));
+
+        p = p.withActivation(Activation.newInstance());
+
+        assertActivation(false, p, newContext(null, null));
+    }
+
+    @Test
+    void testWithNameOnly_UserProperty() throws Exception {
+        Profile profile = newProfile("prop", null);
+
+        assertActivation(true, profile, newContext(newProperties("prop", "value"), null));
+
+        assertActivation(false, profile, newContext(newProperties("prop", ""), null));
+
+        assertActivation(false, profile, newContext(newProperties("other", "value"), null));
+    }
+
+    @Test
+    void testWithNameOnly_SystemProperty() throws Exception {
+        Profile profile = newProfile("prop", null);
+
+        assertActivation(true, profile, newContext(null, newProperties("prop", "value")));
+
+        assertActivation(false, profile, newContext(null, newProperties("prop", "")));
+
+        assertActivation(false, profile, newContext(null, newProperties("other", "value")));
+    }
+
+    @Test
+    void testWithNegatedNameOnly_UserProperty() throws Exception {
+        Profile profile = newProfile("!prop", null);
+
+        assertActivation(false, profile, newContext(newProperties("prop", "value"), null));
+
+        assertActivation(true, profile, newContext(newProperties("prop", ""), null));
+
+        assertActivation(true, profile, newContext(newProperties("other", "value"), null));
+    }
+
+    @Test
+    void testWithNegatedNameOnly_SystemProperty() throws Exception {
+        Profile profile = newProfile("!prop", null);
+
+        assertActivation(false, profile, newContext(null, newProperties("prop", "value")));
+
+        assertActivation(true, profile, newContext(null, newProperties("prop", "")));
+
+        assertActivation(true, profile, newContext(null, newProperties("other", "value")));
+    }
+
+    @Test
+    void testWithValue_UserProperty() throws Exception {
+        Profile profile = newProfile("prop", "value");
+
+        assertActivation(true, profile, newContext(newProperties("prop", "value"), null));
+
+        assertActivation(false, profile, newContext(newProperties("prop", "other"), null));
+
+        assertActivation(false, profile, newContext(newProperties("prop", ""), null));
+    }
+
+    @Test
+    void testWithValue_SystemProperty() throws Exception {
+        Profile profile = newProfile("prop", "value");
+
+        assertActivation(true, profile, newContext(null, newProperties("prop", "value")));
+
+        assertActivation(false, profile, newContext(null, newProperties("prop", "other")));
+
+        assertActivation(false, profile, newContext(null, newProperties("other", "")));
+    }
+
+    @Test
+    void testWithNegatedValue_UserProperty() throws Exception {
+        Profile profile = newProfile("prop", "!value");
+
+        assertActivation(false, profile, newContext(newProperties("prop", "value"), null));
+
+        assertActivation(true, profile, newContext(newProperties("prop", "other"), null));
+
+        assertActivation(true, profile, newContext(newProperties("prop", ""), null));
+    }
+
+    @Test
+    void testWithNegatedValue_SystemProperty() throws Exception {
+        Profile profile = newProfile("prop", "!value");
+
+        assertActivation(false, profile, newContext(null, newProperties("prop", "value")));
+
+        assertActivation(true, profile, newContext(null, newProperties("prop", "other")));
+
+        assertActivation(true, profile, newContext(null, newProperties("other", "")));
+    }
+
+    @Test
+    void testWithValue_UserPropertyDominantOverSystemProperty() throws Exception {
+        Profile profile = newProfile("prop", "value");
+
+        Properties props1 = newProperties("prop", "value");
+        Properties props2 = newProperties("prop", "other");
+
+        assertActivation(true, profile, newContext(props1, props2));
+
+        assertActivation(false, profile, newContext(props2, props1));
+    }
+}
diff --git a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/SimpleProblemCollector.java b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/SimpleProblemCollector.java
new file mode 100644
index 000000000000..ecf45df50ccb
--- /dev/null
+++ b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/model/profile/SimpleProblemCollector.java
@@ -0,0 +1,121 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl.model.profile;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.maven.api.model.InputLocation;
+import org.apache.maven.api.model.Model;
+import org.apache.maven.api.services.BuilderProblem;
+import org.apache.maven.api.services.ModelBuilderException;
+import org.apache.maven.api.services.ModelProblem;
+import org.apache.maven.api.services.ModelProblemCollector;
+import org.apache.maven.internal.impl.model.DefaultModelProblem;
+
+/**
+ * A simple model problem collector for testing the model building components.
+ */
+public class SimpleProblemCollector implements ModelProblemCollector {
+
+    final List<ModelProblem> problems = new ArrayList<>();
+
+    @Override
+    public List<ModelProblem> getProblems() {
+        return problems;
+    }
+
+    @Override
+    public boolean hasErrors() {
+        return problems.stream()
+                .anyMatch(p -> p.getSeverity() == ModelProblem.Severity.FATAL
+                        || p.getSeverity() == ModelProblem.Severity.ERROR);
+    }
+
+    @Override
+    public boolean hasFatalErrors() {
+        return problems.stream().anyMatch(p -> p.getSeverity() == ModelProblem.Severity.FATAL);
+    }
+
+    @Override
+    public void add(
+            BuilderProblem.Severity severity,
+            ModelProblem.Version version,
+            String message,
+            InputLocation location,
+            Exception exception) {
+        add(new DefaultModelProblem(
+                message,
+                severity,
+                version,
+                null,
+                location != null ? location.getLineNumber() : -1,
+                location != null ? location.getColumnNumber() : -1,
+                exception));
+    }
+
+    @Override
+    public void add(ModelProblem problem) {
+        this.problems.add(problem);
+    }
+
+    @Override
+    public ModelBuilderException newModelBuilderException() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setSource(String location) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setSource(Model model) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public String getSource() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setRootModel(Model model) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Model getRootModel() {
+        throw new UnsupportedOperationException();
+    }
+
+    public List<String> getErrors() {
+        return problems.stream()
+                .filter(p -> p.getSeverity() == ModelProblem.Severity.ERROR)
+                .map(p -> p.getMessage())
+                .toList();
+    }
+
+    public List<String> getWarnings() {
+        return problems.stream()
+                .filter(p -> p.getSeverity() == ModelProblem.Severity.WARNING)
+                .map(p -> p.getMessage())
+                .toList();
+    }
+}