injector.bindImplicit(clazz);
                    } catch (ClassNotFoundException e) {
                        // ignore
                        e.printStackTrace();
                    }
                }
            }

        } catch (IOException e) {
            throw new MavenException(e);
        }
        injector.getBindings().keySet().stream()

        DefaultVersion(VersionScheme versionScheme, String delegateValue) {
            this.versionScheme = versionScheme;
            try {
                this.delegate = versionScheme.parseVersion(delegateValue);
            } catch (InvalidVersionSpecificationException e) {
                throw new VersionParserException("Unable to parse version: " + delegateValue, e);
            }
        }

        @Override

            if (reader != null) {
                return xml.read(reader, request.isStrict());
            } else {
                return xml.read(inputStream, request.isStrict());
            }
        } catch (Exception e) {
            throw new XmlReaderException("Unable to read toolchains: " + getMessage(e), getLocation(e), e);
        }
    }

    @Override

                }
            } else {
                try (InputStream is = url.openStream()) {
                    return xml.read(is, request.isStrict(), source);
                }
            }
        } catch (Exception e) {
            throw new XmlReaderException("Unable to read model: " + getMessage(e), getLocation(e), e);
        }
    }

    @Override

                    Files.delete(artifactPath.getParent());
                    Files.delete(artifactPath.getParent().getParent());
                } catch (DirectoryNotEmptyException e) {
                    // ignore
                }
            }
        } catch (IOException e) {
            LOGGER.error("Error while cleaning project local repository", e);
        }
    }

    /**

                    if ("root".equals(parser.getAttributeLocalName(i))) {
                        return Boolean.parseBoolean(parser.getAttributeValue(i));
                    }
                }
            }
        } catch (IOException | XMLStreamException e) {
            // The root locator can be used very early during the setup of Maven,
            // even before the arguments from the command line are parsed.  Any exception

                    artifactManager.setPath(artifact, path);
                    paths.put(artifact, path);
                }
            }
            return () -> paths;
        } catch (ArtifactResolutionException e) {
            throw new ArtifactResolverException("Unable to resolve artifact: " + e.getMessage(), e);
        }
    }

            return new Xpp3Dom(XmlNodeStaxBuilder.build(
                    new StringReader("<configuration>" + xml + "</configuration>"),
                    (XmlNodeStaxBuilder.InputLocationBuilderStax) null));
        } catch (XMLStreamException e) {
            throw new IllegalArgumentException(e);
        }
    }

    @Test
    void testMinimal() throws BeanConfigurationException {
        SomeBean bean = new SomeBean();

                        Language.JAVA_FAMILY,
                        "jar",
                        "tests",
                        false,
                        JavaPathType.CLASSES,
                        JavaPathType.PATCH_MODULE),
                new DefaultType(Type.MODULAR_JAR, Language.JAVA_FAMILY, "jar", null, false, JavaPathType.MODULES),

                }

                @Override
                public Node getRoot() {
                    return session.getNode(result.getRoot(), request.getVerbose());
                }
            };
        } catch (DependencyCollectionException e) {
            throw new DependencyCollectorException("Unable to collect dependencies", e);
        }
    }