}
        }
        result.setLocations(locations);

        return result;
    } // -- InputLocation merge( InputLocation, InputLocation, java.util.Collection )

    /**
     *
     *
     * @param locations
     */
    public void setLocations(java.util.Map<Object, InputLocation> locations) {
        this.locations = locations;
    } // -- void setLocations( java.util.Map )

    /**

    } // -- InputSource clone()

    /**
     * Get the path/URL of the POM or {@code null} if unknown.
     *
     * @return String
     */
    public String getLocation() {
        return this.location;
    } // -- String getLocation()

    /**
     * Get the identifier of the POM in the format {@code
     * <groupId>:<artifactId>:<version>}.
     *
     * @return String
     */

        } catch (XMLStreamException e) {
            throw new SettingsParseException(
                    e.getMessage(),
                    e.getLocation().getLineNumber(),
                    e.getLocation().getColumnNumber(),
                    e);
        }
    }

    @Override
    public Settings read(Reader input, Map<String, ?> options) throws IOException {

        } catch (XMLStreamException e) {
            throw new ToolchainsParseException(
                    e.getMessage(),
                    e.getLocation().getLineNumber(),
                    e.getLocation().getColumnNumber(),
                    e);
        }
    }

    @Override
    public PersistedToolchains read(Reader input, Map<String, ?> options) throws IOException {

                            "Conflicting extension %s: %s vs %s",
                            key,
                            formatLocation(conflict.getLocation("")),
                            formatLocation(coreExtension.getLocation(""))));
                }
            }
        }
        if (!conflicts.isEmpty()) {
            context.logger.warn("Found " + conflicts.size() + " extension conflict(s):");

            }
            target.setProperties(merged);
            target.setLocation(
                    "properties",
                    InputLocation.merge(
                            target.getLocation("properties"), source.getLocation("properties"), sourceDominant));
        }

        private void putAll(Map<Object, Object> s, Map<Object, Object> t, Object excludeKey) {
            for (Map.Entry<Object, Object> e : t.entrySet()) {

        assertNotNull(source);
        assertInstanceOf(Sources.ResolvedPathSource.class, source);
        assertNull(source.getPath());
        assertEquals(path.toString(), source.getLocation());
        assertEquals(modelId, source.getModelId());
    }

    @Test
    void testPathSourceFunctionality() {
        // Test basic source functionality
        Path path = Paths.get("/tmp");

        @Override
        public InputStream getInputStream() throws IOException {
            return source.openStream();
        }

        @Override
        public String getLocation() {
            return source.getLocation();
        }

        @Override
        public ModelSource2 getRelatedSource(String relPath) {
            Source rel = source.resolve(relPath);

            assertTrue(
                    location.getSource().getLocation().contains("pom-with-profiles/pom.xml"),
                    "Profile location should contain 'pom-with-profiles/pom.xml', but was: "
                            + location.getSource().getLocation() + " for profile: " + profile.getId());

            // This demonstrates the cross-platform path behavior:

    @Override
    public int getLineNumber() {
        return lineNumber;
    }

    @Override
    public int getColumnNumber() {
        return columnNumber;
    }

    @Override
    public String getLocation() {
        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (!buffer.isEmpty()) {
                buffer.append(", ");
            }