}

    /**
     * Creates upgrade options with only the --infer option set.
     *
     * @param infer the --infer option value
     * @return configured upgrade options
     */
    public static UpgradeOptions createOptionsWithInfer(boolean infer) {
        return createOptions(null, infer, null, null, null);
    }

    /**
     * Creates a simple POM XML string for testing.

        if (useAll) {
            return true;
        }

        // Check if --infer is explicitly set
        if (options.infer().isPresent()) {
            return options.infer().get();
        }

        // Apply default behavior: if no specific options are provided, enable --infer
        if (options.infer().isEmpty()
                && options.model().isEmpty()
                && options.plugins().isEmpty()

            return Optional.of(commandLine.getOptionValue(CLIManager.DIRECTORY));
        }
        return Optional.empty();
    }

    @Override
    @Nonnull
    public Optional<Boolean> infer() {
        if (commandLine.hasOption(CLIManager.INFER)) {
            return Optional.of(Boolean.TRUE);
        }
        return Optional.empty();
    }

    @Override
    @Nonnull
    public Optional<Boolean> model() {

        CommonsCliUpgradeOptions options = CommonsCliUpgradeOptions.parse(args);

        assertTrue(options.modelVersion().isPresent(), "--model-version option should be present");
        assertEquals("4.1.0", options.modelVersion().get(), "--model-version should be 4.1.0");

        assertTrue(options.infer().isPresent(), "--infer option should be present");

    @DisplayName("Applicability")
    class ApplicabilityTests {

        @Test
        @DisplayName("should be applicable when --infer option is true")
        void shouldBeApplicableWhenInferOptionTrue() {
            UpgradeOptions options = mock(UpgradeOptions.class);
            when(options.infer()).thenReturn(Optional.of(true));
            when(options.all()).thenReturn(Optional.empty());

        context.info("-m, --model-version <version> Target POM model version (4.0.0 or 4.1.0)");
        context.info("-d, --directory <path> Directory to use as starting point for POM discovery");
        context.info("-i, --infer           Remove redundant information that can be inferred by Maven");
        context.info("    --model           Fix Maven 4 compatibility issues in POM files");

     * Should use inference when upgrading (remove redundant information).
     *
     * @return an {@link Optional} containing the boolean value {@code true} if specified, or empty
     */
    @Nonnull
    Optional<Boolean> infer();

    /**
     * Should fix Maven 4 compatibility issues in POMs.
     * This includes fixing unsupported combine attributes, duplicate dependencies,
     * unsupported expressions, and other Maven 4 validation issues.

  CHECK_EQ(TF_OK, TF_GetCode(status_)) << TF_Message(status_);

  // Infer shape when everything is known.
  CheckOutputShapes(matmul_op,
                    /*input_shapes*/ {make_shape({3, 2}), make_shape({2, 4})},
                    /*input_tensors*/ {},
                    /*expected_shape*/ make_shape({3, 4}));

  // Infer shape when second operand has unknown shape.
  CheckOutputShapes(matmul_op,

 *
 * <h3>All-in-One Option</h3>
 * The {@code --all} option is a convenience flag equivalent to {@code --model 4.1.0 --infer --fix-model --plugins}.
 * It performs a complete upgrade to Maven 4.1.0 with all optimizations, compatibility fixes, and plugin upgrades.
 *
 * <h3>Maven 4 Compatibility Fixes</h3>

        // Although we cannot directly verify the super constructor call with Mockito for a real class,
        // we can infer its correct behavior if the object is successfully constructed and its own fields are correct.
        // The super constructor is called with (domainHandle, 0, acct_flags, null, 0)