/**
     * Creates artifact coordinates.
     *
     * @param request the request holding coordinates creation parameters
     * @return an {@code ArtifactCoordinates}, never {@code null}
     * @throws IllegalArgumentException if {@code request} is null or {@code request.session} is null or invalid
     */
    @Nonnull
    ArtifactCoordinates create(@Nonnull ArtifactCoordinatesFactoryRequest request);

    /**

            ArtifactRepository localRepository)
            throws ArtifactDeploymentException;

    /**
     * Deploy an artifact from a particular file.
     *
     * @param source the file to deploy
     * @param artifact the artifact definition
     * @param deploymentRepository the repository to deploy to
     * @param localRepository the local repository to install into

        get() = when (this) {
            is CtField -> "$name:$signature"
            is CtConstructor -> "<init>$signature"
            is CtMethod -> "$name$signature"
            else -> throw IllegalArgumentException("Unsupported javassist member type '${this::class}'")
        }
}


internal
enum class MemberType {
    TYPE, CONSTRUCTOR, FIELD, METHOD
}


private

        super.transferInitiated(event);
    }

    @Override
    public void transferCorrupted(TransferEvent event) throws TransferCancelledException {
        overridePreviousTransfer(event);

        super.transferCorrupted(event);
    }

    @Override
    public void transferProgressed(TransferEvent event) throws TransferCancelledException {
        TransferResource resource = event.getResource();
        transfers.put(

import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 */
class ConcurrencyDependencyGraphTest {
    @Test
    void testConcurrencyGraphPrimaryVersion()
            throws InvalidPluginDescriptorException, PluginVersionResolutionException, PluginDescriptorParsingException,
                    NoPluginFoundForPrefixException, MojoNotFoundException, PluginNotFoundException,

 */
class PluginDescriptorBuilderTest {

    private PluginDescriptor build(String resource) throws IOException, PlexusConfigurationException {
        try (InputStream is = getClass().getResourceAsStream(resource)) {
            return new PluginDescriptorBuilder().build(is, null);
        }
    }

    @Test
    void testBuildReader() throws Exception {
        PluginDescriptor pd = build("/plugin.xml");

        assertSame(clock, newClock, "withZone() should return the same clock instance");
    }

    @Test
    @DisplayName("MonotonicClock should maintain monotonic time progression")
    void testMonotonicBehavior() throws InterruptedException {
        Instant first = MonotonicClock.now();
        Thread.sleep(10); // Small delay
        Instant second = MonotonicClock.now();
        Thread.sleep(10); // Small delay

 *
 * @since 3.0
 */
public interface LifecycleTaskSegmentCalculator {
    List<TaskSegment> calculateTaskSegments(MavenSession session)
            throws PluginNotFoundException, PluginResolutionException, PluginDescriptorParsingException,
                    MojoNotFoundException, NoPluginFoundForPrefixException, InvalidPluginDescriptorException,

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

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

            if (cells.size() != 1) {
                throw new RuntimeException(String.format("Expected 1 cell in <tr>, found: %s", tr));
            }
            String methodName = cells.get(0).getTextContent().trim();
            Collection<MethodMetaData> methods = classDoc.getClassMetaData().findDeclaredMethods(methodName);
            if (methods.isEmpty()) {