}

  private WeakReference<ClassLoader> useFrqInSeparateLoader() throws Exception {
    final ClassLoader myLoader = getClass().getClassLoader();
    URLClassLoader sepLoader = new URLClassLoader(getClassPathUrls(), myLoader.getParent());
    // sepLoader is the loader that we will use to load the parallel FinalizableReferenceQueue (FRQ)
    // and friends, and that we will eventually expect to see garbage-collected. The assumption

        MavenProject project0 = getProjectWithDependencies(pom0);
        MavenProject project1 = getProjectWithDependencies(pom1);

        assertEquals(pom0Basedir, project1.getParent().getBasedir());
        Set set = project1.getArtifacts();
        assertNotNull(set, "No artifacts");
        assertTrue(set.size() > 0, "No Artifacts");

            boolean isAdded = projectsIncludingParents.add(project);
            MavenProject parent = project.getParent();
            while (isAdded && parent != null) {
                isAdded = projectsIncludingParents.add(parent);
                parent = parent.getParent();
            }
        }

        final Stream<String> projectProfiles = projectsIncludingParents.stream()

  }

  private WeakReference<ClassLoader> useFrqInSeparateLoader() throws Exception {
    final ClassLoader myLoader = getClass().getClassLoader();
    URLClassLoader sepLoader = new URLClassLoader(getClassPathUrls(), myLoader.getParent());
    // sepLoader is the loader that we will use to load the parallel FinalizableReferenceQueue (FRQ)
    // and friends, and that we will eventually expect to see garbage-collected. The assumption

            if (scope != null) return scope
        }

        if (parent is KtClassBody) {
            val classDescriptor = bindingContext[BindingContext.CLASS, parent.getParent()] as? ClassDescriptorWithResolutionScopes
            if (classDescriptor != null) {
                return classDescriptor.scopeForMemberDeclarationResolution
            }
        }
        if (parent is KtFile) {

        }
    }

    private void write(Path metadataPath, Metadata metadata) throws RepositoryException {
        try {
            Files.createDirectories(metadataPath.getParent());
            try (OutputStream output = Files.newOutputStream(metadataPath)) {
                new MetadataStaxWriter().write(output, metadata);
            }
        } catch (IOException | XMLStreamException e) {

                            Path moduleFile = defaultModelBuilder
                                    .getModelProcessor()
                                    .locateExistingPom(pom.getParent().resolve(module));
                            if (moduleFile != null) {
                                toLoad.add(moduleFile);
                            }
                        }

     * @return the wildcard
     */
    public final String getWildcard () {
        return this.wildcard;
    }


    /**
     * @return the parent
     */
    public final SmbResource getParent () {
        return this.parent;
    }


    private final boolean filter ( FileEntry fe ) {
        String name = fe.getName();
        if ( name.length() < 3 ) {
            int h = name.hashCode();

public class ParamMap<K, V> implements Map<K, V> {

    private final Map<K, V> parent;

    public ParamMap(final Map<K, V> parent) {
        this.parent = parent;
    }

    public Map<K, V> getParent() {
        return parent;
    }

    protected Object toCamelCase(final Object key) {
        if (key == null) {
            return key;
        }
        String keyStr = key.toString();

        }
        return artifacts;
    }

    void write(Model model, Path dest) throws IOException, XMLStreamException {
        String version = model.getModelVersion();
        Files.createDirectories(dest.getParent());
        try (Writer w = Files.newBufferedWriter(dest)) {
            MavenStaxWriter writer = new MavenStaxWriter();
            writer.setNamespace(String.format(NAMESPACE_FORMAT, version));