Set<WorkspaceReader> workspaceReaders = new LinkedHashSet<>();
        // 1) Reactor workspace reader
        WorkspaceReader reactorReader = lookup.lookup(WorkspaceReader.class, ReactorReader.HINT);
        workspaceReaders.add(reactorReader);
        // 2) Repository system session-scoped workspace reader (contains ide and exec request reader)

        for (WorkspaceReader reader : readers) {
            versions.addAll(reader.findVersions(artifact));
        }

        return Collections.unmodifiableList(new ArrayList<>(versions));
    }

    public void setReaders(Collection<WorkspaceReader> readers) {
        requireNonNull(readers, "readers");
        // skip possible null entries
        this.readers = Collections.unmodifiableList(

        try (InputStream is = Files.newInputStream(settingsFile.toPath())) {
            SettingsStaxReader reader = new SettingsStaxReader();
            InputSource source = new InputSource(settingsFile.toString());
            return new Settings(reader.read(is, true, source));
        }
    }

    }

    protected static File getFileForClasspathResource(String resource)
            throws FileNotFoundException, URISyntaxException {
        ClassLoader cloader = Thread.currentThread().getContextClassLoader();

        URL resourceUrl = cloader.getResource(resource);

        if (resourceUrl == null) {
            throw new FileNotFoundException("Unable to find: " + resource);
        }

        return read(Files.newInputStream(input.toPath()), options);
    }

    public Metadata read(Reader input, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(input, "input cannot be null");

        try (Reader in = input) {
            return new Metadata(new MetadataStaxReader().read(in, isStrict(options)));
        } catch (XMLStreamException e) {

              </models>
              <templates>
                <template>merger.vm</template>
                <template>transformer.vm</template>
                <template>reader-stax.vm</template>
                <template>writer-stax.vm</template>
              </templates>
              <params>
                <param>forcedIOModelVersion=1.2.0</param>

            version = artifact.getVersion();
            localRepo = session.getLocalRepository().getBasePath();
            WorkspaceReader reader = session.getWorkspaceReader();
            workspace = (reader != null) ? reader.getRepository() : null;
            repositories = new ArrayList<>(request.getRepositories().size());
            boolean repoMan = false;

        ExtensionDescriptor extensionDescriptor = new ExtensionDescriptor();

        XmlNode dom;
        try {
            XMLStreamReader reader = WstxInputFactory.newFactory().createXMLStreamReader(is);
            dom = XmlNodeStaxBuilder.build(reader);
        } catch (XMLStreamException e) {
            throw new IOException(e.getMessage(), e);
        }

        if (!"extension".equals(dom.getName())) {

    Path locateExistingPom(@Nonnull Path project);

    /**
     * Reads the model from the specified byte stream. The stream will be automatically closed before the method
     * returns.
     *
     * @param request The reader request to deserialize the model, must not be {@code null}.
     * @return The deserialized model, never {@code null}.
     * @throws IOException If the model could not be deserialized.

        Map<String, String> headers = (Map<String, String>) systemSessionFactory
                .newRepositorySession(request)
                .getConfigProperties()
                .get(ConfigurationProperties.HTTP_HEADERS + "." + server.getId());
        assertNotNull(headers);
        assertEquals(1, headers.size());
        assertEquals("value", headers.get("header"));
    }

    @Test