@SuppressWarnings("unchecked") // implementation is "fully variant"
  static <T> Optional<T> withType() {
    return (Optional<T>) INSTANCE;
  }

  private Absent() {}

  @Override
  public boolean isPresent() {
    return false;
  }

  @Override
  public T get() {
    throw new IllegalStateException("Optional.get() cannot be called on an absent value");
  }

  @Override
  public T or(T defaultValue) {

        this.components = components;
    }

    @Override
    public <T> T lookup(Class<T> type) {
        Optional<T> optional = lookupOptional(type);
        if (optional.isPresent()) {
            return optional.get();
        } else {
            throw new LookupException("No mapping for key: " + type.getName());
        }
    }

    @Override

        public String testDoUpgradeLogic(UpgradeContext context, String expectedTargetModel) {
            UpgradeOptions options = context.options();
            if (options.modelVersion().isPresent()) {
                return options.modelVersion().get();
            } else if (options.all().orElse(false)) {
                return "4.1.0";
            } else {
                return "4.0.0";
            }

        boolean useAll = options.all().orElse(false);
        if (useAll) {
            return true;
        }

        // Check specific option
        if (specificOption.isPresent()) {
            return specificOption.get();
        }

        // Apply default behavior when no specific options are provided
        if (defaultWhenNoOptionsSpecified
                && options.infer().isEmpty()

     * if applicable.
     */
    default boolean effectiveVerbose() {
        return options().isPresent() && options().orElseThrow().verbose().orElse(false)
                || ciInfo().isPresent() && ciInfo().orElseThrow().isVerbose();
    }

        }.writePlan(System.out::println, plan);

        plan.allSteps().forEach(phase -> {
            phase.predecessors.forEach(
                    pred -> assertTrue(plan.step(pred.project, pred.name).isPresent(), "Phase not present: " + pred));
        });
    }

    @Test
    void testAlias() {
        MavenProject p1 = new MavenProject();
        p1.setArtifactId("p1");
        p1.setCollectedProjects(List.of());

    }

    @Override
    public boolean presentInConfig(
            org.apache.maven.model.Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
        return getActivationPackaging(profile).isPresent();
    }

    private static boolean isPackaging(ProfileActivationContext context, String p) {
        String packaging = context.getUserProperties().get(ProfileActivationContext.PROPERTY_NAME_PACKAGING);

        }
    }
    manifest.attributes("Class-Path-Source" to "manifestClasspath")
    manifest.attributes("Class-Path" to classpath)
    if (app.mainClassName.isPresent) {
        manifest.attributes("Main-Class" to app.mainClassName)
    }

        })
    }

    val integTestUseAgentSysPropName = "org.gradle.integtest.agent.allowed"
    val integtestAgentAllowed = project.providers.gradleProperty(integTestUseAgentSysPropName);
    if (integtestAgentAllowed.isPresent) {
        val shouldUseAgent = integtestAgentAllowed.get().toBoolean()
        systemProperties[integTestUseAgentSysPropName] = shouldUseAgent.toString()
    }
}


private

        assertNotNull(resolved);
        assertNotNull(resolved.getPath());
        Optional<Path> op = session.getArtifactPath(resolved);
        assertTrue(op.isPresent(), "Expected " + op + ".isPresent() to return true");
        assertEquals(resolved.getPath(), op.get());
    }

    @Test
    void testBuildProject() {