return () -> {
                Object[] args =
                        Stream.of(this.args).map(compiler).map(Supplier::get).toArray();
                return constructor.create(args);
            };
        }

        @Override
        public String toString() {
            return "BindingToConstructor[" + constructor + "]" + getDependencies();
        }
    }

    public void info(String format, Object... arguments) {}

    public void info(String msg, Throwable t) {}

    public boolean isInfoEnabled(Marker marker) {
        return false;
    }

    public void info(Marker marker, String msg) {}

    public void info(Marker marker, String format, Object arg) {}

    public void info(Marker marker, String format, Object arg1, Object arg2) {}

     * WARN according to the format outlined above.
     */
    @Override
    public void warn(String format, Object arg1, Object arg2) {
        super.warn(format, arg1, arg2);
        logLevelRecorder.record(Level.WARN);
    }

    /**
     * Perform double parameter substitution before logging the message of level
     * WARN according to the format outlined above.

import java.util.ArrayList;
import java.util.List;

/**
 * CleanArgument
 */
public class CleanArgument {
    public static String[] cleanArgs(String[] args) {
        List<String> cleaned = new ArrayList<>();

        StringBuilder currentArg = null;

        for (String arg : args) {
            boolean addedToBuffer = false;

            if (arg.startsWith("\"")) {

    private <T> T createProxy(Key<T> key, Provider<T> unscoped) {
        InvocationHandler dispatcher = (proxy, method, args) -> {
            method.setAccessible(true);
            try {
                return method.invoke(getScopeState().scope(key, unscoped).get(), args);
            } catch (InvocationTargetException e) {
                throw e.getCause();
            }
        };

            }
        }
        return i;
    }

    /**
     * <p>main.</p>
     *
     * @param args a {@link String} object.
     * @throws org.openjdk.jmh.runner.RunnerException if any.
     */
    public static void main(String... args) throws RunnerException {
        Options opts = new OptionsBuilder().forks(1).build();
        new Runner(opts).run();
    }

     */
    private static Path createPathProxy(String value) {
        return (Path) Proxy.newProxyInstance(
                ExclusionArtifactFilter.class.getClassLoader(), new Class[] {Path.class}, (proxy1, method, args) -> {
                    if ("toString".equals(method.getName())) {
                        return value;
                    }
                    throw new UnsupportedOperationException();
                });
    }

                .build());
    }

    public CommandLine parse(String[] args) throws ParseException {
        // We need to eat any quotes surrounding arguments...
        String[] cleanArgs = CleanArgument.cleanArgs(args);

        CommandLineParser parser = new DefaultParser();

        return parser.parse(options, cleanArgs);
    }

 *
 * @since 3.2.4
 */
public class UnsupportedSlf4jBindingConfiguration extends BaseSlf4jConfiguration {

    /**
     * @deprecated the arguments are ignored. Use the no-args constructor.
     */
    @Deprecated
    public UnsupportedSlf4jBindingConfiguration(String slf4jBinding, Map<URL, Set<Object>> supported) {}

    public UnsupportedSlf4jBindingConfiguration() {}

    @Override

    Properties systemProperties = new Properties();

    MavenExecutionRequest request;

    CliRequest(String[] args, ClassWorld classWorld) {
        this.args = args;
        this.classWorld = classWorld;
        this.request = new DefaultMavenExecutionRequest();
    }

    public String[] getArgs() {
        return args;
    }

    public CommandLine getCommandLine() {
        return commandLine;
    }