This is an automated email from the ASF dual-hosted git repository.

gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git


The following commit(s) were added to refs/heads/master by this push:
     new 60d9e4989a [MNG-8112] Honor export descriptors from the extension 
classpath (#13101)
60d9e4989a is described below

commit 60d9e4989a730ea85d0eae56f64b4760a48077f7
Author: Goutam Adwant <[email protected]>
AuthorDate: Fri Nov 6 09:40:45 2026 -0800

    [MNG-8112] Honor export descriptors from the extension classpath (#13101)
    
    * [MNG-8112] Honor export descriptors from the extension classpath
    
    Read package and artifact exports from maven.ext.class.path entries in both 
CLI implementations. Reuse descriptor discovery without moving extensions into 
the core realm or changing extension precedence.
    
    Cover JAR and directory entries, optional descriptors, package isolation, 
artifact filtering, and mixed extension loading with unit tests and Core ITs.
    
    * [MNG-8112] Suppress deprecation warnings in extension classpath test
    
    Use SuppressWarnings instead of marking the regression test itself 
deprecated. Keep the warning suppression scoped to the test class.
    
    * [MNG-8112] Deduplicate extension classpath entries in active CLI
    
    Drop the deprecated embedder changes and keep descriptor discovery in the 
active Maven CLI. Resolve classpath entries to real paths before processing 
while retaining the first spelling. Discover each descriptor independently so a 
malformed optional descriptor does not skip later valid exports. Cover relative 
and symlink aliases and malformed-first ordering.
---
 .../invoker/PlexusContainerCapsuleFactory.java     |  23 +-
 .../invoker/PlexusContainerCapsuleFactoryTest.java | 278 +++++++++++++++++++++
 .../maven/it/MavenITmng5771CoreExtensionsTest.java |  45 ++++
 .../META-INF/maven/extension.xml                   |  24 ++
 .../its/classpath_extension/marker.properties      |  17 ++
 .../client-classpath/pom.xml                       |  45 ++++
 6 files changed, 428 insertions(+), 4 deletions(-)

diff --git 
a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/PlexusContainerCapsuleFactory.java
 
b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/PlexusContainerCapsuleFactory.java
index a6db5a9813..cb1eda8210 100644
--- 
a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/PlexusContainerCapsuleFactory.java
+++ 
b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/PlexusContainerCapsuleFactory.java
@@ -19,6 +19,7 @@
 package org.apache.maven.cling.invoker;
 
 import java.io.File;
+import java.io.IOException;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -93,10 +94,14 @@ protected DefaultPlexusContainer container(
                 coreRealm,
                 coreEntry.getExportedArtifacts(),
                 coreExtensionSelector.selectCoreExtensions(invoker, context));
-        List<CoreExtensionEntry> loadedExtensionsEntries =
-                
loadedExtensions.stream().map(LoadedCoreExtension::entry).toList();
+        List<CoreExtensionEntry> loadedExtensionsEntries = new ArrayList<>(
+                
loadedExtensions.stream().map(LoadedCoreExtension::entry).toList());
         ClassRealm containerRealm =
                 setupContainerRealm(context.logger, classWorld, coreRealm, 
extClassPath, loadedExtensionsEntries);
+        for (Path entry : extClassPath) {
+            loadedExtensionsEntries.add(
+                    CoreExtensionEntry.discoverFrom(containerRealm, 
List.of(entry.toFile()), null, null));
+        }
         ContainerConfiguration cc = new DefaultContainerConfiguration()
                 .setClassWorld(classWorld)
                 .setRealm(containerRealm)
@@ -211,11 +216,21 @@ protected List<Path> parseExtClasspath(C context) throws 
Exception {
             }
         }
         ArrayList<Path> jars = new ArrayList<>();
+        Set<Path> seen = new HashSet<>();
         if (extClassPath != null && !extClassPath.isEmpty()) {
             for (String jar : extClassPath.split(File.pathSeparator)) {
                 Path file = context.cwd.resolve(jar);
-                context.logger.debug("  included '" + file + "'");
-                jars.add(file);
+                Path realPath;
+                try {
+                    realPath = file.toRealPath();
+                } catch (IOException e) {
+                    // Preserve the existing handling of optional entries that 
do not exist.
+                    realPath = file.toAbsolutePath().normalize();
+                }
+                if (seen.add(realPath)) {
+                    context.logger.debug("  included '" + file + "'");
+                    jars.add(file);
+                }
             }
         }
         return jars;
diff --git 
a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/PlexusContainerCapsuleFactoryTest.java
 
b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/PlexusContainerCapsuleFactoryTest.java
new file mode 100644
index 0000000000..c8f99cd855
--- /dev/null
+++ 
b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/PlexusContainerCapsuleFactoryTest.java
@@ -0,0 +1,278 @@
+/*
+ * 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.cling.invoker;
+
+import javax.tools.ToolProvider;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+
+import org.apache.maven.api.cli.ParserRequest;
+import org.apache.maven.api.cli.mvn.MavenOptions;
+import org.apache.maven.classrealm.ClassRealmManager;
+import org.apache.maven.cling.invoker.mvn.MavenContext;
+import org.apache.maven.cling.invoker.mvn.MavenInvoker;
+import org.apache.maven.cling.invoker.mvn.MavenParser;
+import org.apache.maven.cling.logging.Slf4jConfiguration;
+import org.apache.maven.extension.internal.CoreExports;
+import org.apache.maven.jline.JLineMessageBuilderFactory;
+import org.apache.maven.model.Plugin;
+import org.codehaus.plexus.DefaultPlexusContainer;
+import org.codehaus.plexus.classworlds.ClassWorld;
+import org.codehaus.plexus.classworlds.realm.ClassRealm;
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.artifact.DefaultArtifact;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.slf4j.LoggerFactory;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+class PlexusContainerCapsuleFactoryTest {
+    @TempDir
+    Path directory;
+
+    private ClassWorld world;
+    private ClassLoader originalClassLoader;
+    private DefaultPlexusContainer container;
+
+    @BeforeEach
+    void setUp() {
+        originalClassLoader = Thread.currentThread().getContextClassLoader();
+        world = new ClassWorld("plexus.core", getClass().getClassLoader());
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+        try {
+            if (container != null) {
+                container.dispose();
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(originalClassLoader);
+            world.close();
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void exportsPackagesToPlugins(boolean jar) throws Exception {
+        Path extension = extension(jar, true);
+        createContainer(List.of("-Dmaven.ext.class.path=" + extension));
+
+        ClassRealm pluginRealm = pluginRealm(List.of());
+        Class<?> exported = pluginRealm.loadClass("extension.api.Exported");
+        assertSame(container.getContainerRealm(), exported.getClassLoader());
+        assertThrows(ClassNotFoundException.class, () -> 
pluginRealm.loadClass("extension.internal.Private"));
+
+        ClassRealm coreRealm = world.getClassRealm("plexus.core");
+        assertEquals(0, coreRealm.getURLs().length);
+        assertThrows(ClassNotFoundException.class, () -> 
coreRealm.loadClass("extension.api.Exported"));
+        ClassRealm otherExtension = 
coreRealm.createChildRealm("coreExtension>other");
+        assertThrows(ClassNotFoundException.class, () -> 
otherExtension.loadClass("extension.api.Exported"));
+        
assertTrue(container.lookup(CoreExports.class).getExportedPackages().containsKey("org.apache.maven.api"));
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void filtersExportedArtifactsFromPlugins(boolean jar) throws Exception {
+        Path extension = extension(jar, true);
+        createContainer(List.of("-Dmaven.ext.class.path=" + extension));
+
+        Path dependency = 
Files.createDirectory(directory.resolve("dependency"));
+        Path retained = Files.createDirectory(directory.resolve("retained"));
+        ClassRealm pluginRealm = pluginRealm(List.of(
+                new 
DefaultArtifact("extension:api:jar:2.0").setFile(dependency.toFile()),
+                new 
DefaultArtifact("extension:retained:jar:1.0").setFile(retained.toFile())));
+        assertArrayEquals(new java.net.URL[] {retained.toUri().toURL()}, 
pluginRealm.getURLs());
+        
assertTrue(container.lookup(CoreExports.class).getExportedArtifacts().contains("org.apache.maven:maven-core"));
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void descriptorIsOptional(boolean jar) throws Exception {
+        Path extension = extension(jar, false);
+        createContainer(List.of("-Dmaven.ext.class.path=" + extension));
+
+        assertSame(
+                container.getContainerRealm(),
+                container
+                        .getContainerRealm()
+                        .loadClass("extension.api.Exported")
+                        .getClassLoader());
+        ClassRealm pluginRealm =
+                pluginRealm(List.of(new 
DefaultArtifact("extension:api:jar:2.0").setFile(extension.toFile())));
+        assertArrayEquals(new java.net.URL[] {extension.toUri().toURL()}, 
pluginRealm.getURLs());
+        
assertFalse(container.lookup(CoreExports.class).getExportedPackages().containsKey("extension.api"));
+    }
+
+    @Test
+    void keepsCoreRealmWithoutExtensions() throws Exception {
+        createContainer(List.of());
+        assertSame(world.getClassRealm("plexus.core"), 
container.getContainerRealm());
+    }
+
+    @Test
+    void mergesClassPathDescriptors() throws Exception {
+        Path withoutDescriptor = extension(true, false);
+        Path jar = extension(true, true);
+        Path classes = extension(false, true);
+        Files.writeString(classes.resolve("META-INF/maven/extension.xml"), """
+                <extension>
+                  
<exportedPackages><exportedPackage>extension.internal</exportedPackage></exportedPackages>
+                  
<exportedArtifacts><exportedArtifact>extension:internal</exportedArtifact></exportedArtifacts>
+                </extension>
+                """);
+        createContainer(List.of("-Dmaven.ext.class.path=" + withoutDescriptor 
+ File.pathSeparator + jar
+                + File.pathSeparator + classes));
+
+        CoreExports exports = container.lookup(CoreExports.class);
+        
assertTrue(exports.getExportedArtifacts().containsAll(List.of("extension:api", 
"extension:internal")));
+        ClassRealm pluginRealm = pluginRealm(List.of());
+        assertSame(
+                container.getContainerRealm(),
+                
pluginRealm.loadClass("extension.api.Exported").getClassLoader());
+        assertSame(
+                container.getContainerRealm(),
+                
pluginRealm.loadClass("extension.internal.Private").getClassLoader());
+    }
+
+    @Test
+    void ignoresMalformedDescriptorWithoutSkippingLaterEntries() throws 
Exception {
+        Path malformed = extension(false, true);
+        Files.writeString(malformed.resolve("META-INF/maven/extension.xml"), 
"<invalid/>");
+        Path valid = extension(true, true);
+        createContainer(List.of("-Dmaven.ext.class.path=" + malformed + 
File.pathSeparator + valid));
+
+        
assertTrue(container.lookup(CoreExports.class).getExportedArtifacts().contains("extension:api"));
+    }
+
+    @Test
+    void processesEquivalentClassPathEntriesOnce() throws Exception {
+        Path extension = extension(true, true);
+        Path alias = directory.relativize(extension);
+        MavenContext context =
+                createContainer(List.of("-Dmaven.ext.class.path=" + extension 
+ File.pathSeparator + alias));
+
+        assertEquals(List.of(extension), new 
PlexusContainerCapsuleFactory<MavenContext>().parseExtClasspath(context));
+        assertEquals(1, container.getContainerRealm().getURLs().length);
+        
assertTrue(container.lookup(CoreExports.class).getExportedArtifacts().contains("extension:api"));
+    }
+
+    @Test
+    void processesSymlinkedClassPathEntryOnce() throws Exception {
+        Path extension = extension(true, true);
+        Path alias = directory.resolve("extension-alias.jar");
+        try {
+            Files.createSymbolicLink(alias, extension);
+        } catch (UnsupportedOperationException | java.io.IOException | 
SecurityException e) {
+            assumeTrue(false, "Symbolic links are unavailable: " + 
e.getMessage());
+        }
+        MavenContext context =
+                createContainer(List.of("-Dmaven.ext.class.path=" + extension 
+ File.pathSeparator + alias));
+
+        assertEquals(List.of(extension), new 
PlexusContainerCapsuleFactory<MavenContext>().parseExtClasspath(context));
+    }
+
+    private MavenContext createContainer(List<String> args) throws Exception {
+        var request = new MavenParser()
+                .parseInvocation(ParserRequest.mvn(args, new 
JLineMessageBuilderFactory())
+                        .cwd(directory)
+                        .userHome(directory)
+                        .embedded(true)
+                        .build());
+        var context =
+                new MavenContext(request, true, (MavenOptions) 
request.options().orElseThrow());
+        context.loggerFactory = LoggerFactory.getILoggerFactory();
+        context.loggerLevel = Slf4jConfiguration.Level.INFO;
+        var invoker = new MavenInvoker(
+                ProtoLookup.builder().addMapping(ClassWorld.class, 
world).build(), null);
+        container = new 
PlexusContainerCapsuleFactory<MavenContext>().container(invoker, context, (i, 
c) -> List.of());
+        return context;
+    }
+
+    private ClassRealm pluginRealm(List<Artifact> artifacts) throws Exception {
+        Plugin plugin = new Plugin();
+        plugin.setGroupId("extension");
+        plugin.setArtifactId("test-plugin");
+        plugin.setVersion("1.0");
+        ClassRealmManager manager = container.lookup(ClassRealmManager.class);
+        return manager.createPluginRealm(plugin, null, null, Map.of("", 
manager.getMavenApiRealm()), artifacts);
+    }
+
+    private Path extension(boolean jar, boolean descriptor) throws Exception {
+        Path root = Files.createTempDirectory(directory, "extension");
+        Path classes = Files.createDirectory(root.resolve("classes"));
+        for (String name : List.of("extension.api.Exported", 
"extension.internal.Private")) {
+            int separator = name.lastIndexOf('.');
+            Path source = root.resolve(name.substring(separator + 1) + 
".java");
+            Files.writeString(
+                    source,
+                    "package " + name.substring(0, separator) + "; public 
class " + name.substring(separator + 1)
+                            + " {}");
+            assertEquals(
+                    0,
+                    ToolProvider.getSystemJavaCompiler()
+                            .run(null, null, null, "-d", classes.toString(), 
source.toString()));
+        }
+        if (descriptor) {
+            Path xml = classes.resolve("META-INF/maven/extension.xml");
+            Files.createDirectories(xml.getParent());
+            Files.writeString(xml, """
+                    <extension>
+                      <exportedPackages>
+                        <exportedPackage>extension.api</exportedPackage>
+                      </exportedPackages>
+                      <exportedArtifacts>
+                        <exportedArtifact>extension:api</exportedArtifact>
+                      </exportedArtifacts>
+                    </extension>
+                    """);
+        }
+        if (!jar) {
+            return classes;
+        }
+        Path archive = root.resolve("extension-1.0.jar");
+        try (JarOutputStream output = new 
JarOutputStream(Files.newOutputStream(archive));
+                var files = Files.walk(classes)) {
+            for (Path file : files.filter(Files::isRegularFile).toList()) {
+                output.putNextEntry(
+                        new 
JarEntry(classes.relativize(file).toString().replace('\\', '/')));
+                Files.copy(file, output);
+                output.closeEntry();
+            }
+        }
+        return archive;
+    }
+}
diff --git 
a/its/core-it-suite/src/test/java/org/apache/maven/it/MavenITmng5771CoreExtensionsTest.java
 
b/its/core-it-suite/src/test/java/org/apache/maven/it/MavenITmng5771CoreExtensionsTest.java
index 335af7791e..4fff21625a 100644
--- 
a/its/core-it-suite/src/test/java/org/apache/maven/it/MavenITmng5771CoreExtensionsTest.java
+++ 
b/its/core-it-suite/src/test/java/org/apache/maven/it/MavenITmng5771CoreExtensionsTest.java
@@ -23,6 +23,8 @@
 
 import org.junit.jupiter.api.Test;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 /**
  * This is a test set for <a 
href="https://issues.apache.org/jira/browse/MNG-5771";>MNG-5771</a>:
  * check that Maven loads core extensions and components contributed by 
<code>.mvn/extensions.xml</code>
@@ -66,6 +68,49 @@ public void testCoreExtensionNoDescriptor() throws Exception 
{
         verifier.verifyErrorFreeLog();
     }
 
+    @Test
+    public void testCoreExtensionFromClassPath() throws Exception {
+        Path testDir = extractResources(RESOURCE_PATH);
+
+        Verifier verifier = newVerifier(testDir);
+        verifier.filterFile("settings-template.xml", "settings.xml");
+
+        verifier = newVerifier(testDir.resolve("client-classpath"));
+        verifier.deleteDirectory("target");
+        verifier.deleteArtifacts("org.apache.maven.its.it-core-extensions");
+        verifier.addCliArgument("-s");
+        verifier.addCliArgument(testDir.resolve("settings.xml").toString());
+        verifier.addCliArgument("-Dmaven.ext.class.path="
+                + 
testDir.resolve("repo/org/apache/maven/its/it-core-extensions/maven-it-core-extensions/0.1/"
+                        + "maven-it-core-extensions-0.1.jar"));
+        verifier.addCliArgument("validate");
+        verifier.execute();
+        verifier.verifyErrorFreeLog();
+    }
+
+    @Test
+    public void testCoreExtensionsWithClassPath() throws Exception {
+        Path testDir = extractResources(RESOURCE_PATH);
+
+        Verifier verifier = newVerifier(testDir);
+        verifier.filterFile("settings-template.xml", "settings.xml");
+
+        verifier = newVerifier(testDir.resolve("client"));
+        verifier.deleteDirectory("target");
+        verifier.deleteArtifacts("org.apache.maven.its.it-core-extensions");
+        verifier.addCliArgument("-s");
+        verifier.addCliArgument(testDir.resolve("settings.xml").toString());
+        verifier.addCliArgument("-Dmaven.ext.class.path=" + 
testDir.resolve("classpath-extension"));
+        
verifier.addCliArgument("-Dclsldr.resourcePaths=org/apache/maven/its/classpath_extension/marker.properties");
+        
verifier.addCliArgument("-Dclsldr.pluginClassLoaderOutput=target/classpath.properties");
+        verifier.addCliArgument("validate");
+        
verifier.addCliArgument("org.apache.maven.its.plugins:maven-it-plugin-class-loader:2.1-SNAPSHOT:load");
+        verifier.execute();
+        verifier.verifyErrorFreeLog();
+        assertNotNull(verifier.loadProperties("target/classpath.properties")
+                
.getProperty("org/apache/maven/its/classpath_extension/marker.properties"));
+    }
+
     //
     // https://issues.apache.org/jira/browse/MNG-5795: Maven extensions can 
not be retrieved from authenticated
     // repositories
diff --git 
a/its/core-it-suite/src/test/resources/mng-5771-core-extensions/classpath-extension/META-INF/maven/extension.xml
 
b/its/core-it-suite/src/test/resources/mng-5771-core-extensions/classpath-extension/META-INF/maven/extension.xml
new file mode 100644
index 0000000000..3002c2bd1f
--- /dev/null
+++ 
b/its/core-it-suite/src/test/resources/mng-5771-core-extensions/classpath-extension/META-INF/maven/extension.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+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.
+-->
+<extension>
+  <exportedPackages>
+    <exportedPackage>org.apache.maven.its.classpath_extension</exportedPackage>
+  </exportedPackages>
+</extension>
diff --git 
a/its/core-it-suite/src/test/resources/mng-5771-core-extensions/classpath-extension/org/apache/maven/its/classpath_extension/marker.properties
 
b/its/core-it-suite/src/test/resources/mng-5771-core-extensions/classpath-extension/org/apache/maven/its/classpath_extension/marker.properties
new file mode 100644
index 0000000000..d05c7e8e0e
--- /dev/null
+++ 
b/its/core-it-suite/src/test/resources/mng-5771-core-extensions/classpath-extension/org/apache/maven/its/classpath_extension/marker.properties
@@ -0,0 +1,17 @@
+# 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.
+source=classpath-extension
diff --git 
a/its/core-it-suite/src/test/resources/mng-5771-core-extensions/client-classpath/pom.xml
 
b/its/core-it-suite/src/test/resources/mng-5771-core-extensions/client-classpath/pom.xml
new file mode 100644
index 0000000000..3b84f373e5
--- /dev/null
+++ 
b/its/core-it-suite/src/test/resources/mng-5771-core-extensions/client-classpath/pom.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+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.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0";>
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>org.apache.maven.its.it-core-extensions</groupId>
+  <artifactId>test-classpath</artifactId>
+  <version>0.1</version>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.its.it-core-extensions</groupId>
+        <artifactId>maven-it-plugin-core-extensions-client</artifactId>
+        <version>0.1</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>validate-component</goal>
+              <goal>validate-classpath</goal>
+            </goals>
+            <phase>validate</phase>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>

Reply via email to