/**
 * Default implementation of artifact versioning.
 *
 */
public class DefaultArtifactVersion implements ArtifactVersion {
    private Integer majorVersion;

    private Integer minorVersion;

    private Integer incrementalVersion;

    private Integer buildNumber;

    private String qualifier;

    private ComparableVersion comparable;

    public DefaultArtifactVersion(String version) {

        problem = new DefaultProblem(null, null, null, Integer.MAX_VALUE, -1, null);
        assertEquals(Integer.MAX_VALUE, problem.getLineNumber());

        // this case is not specified, might also return -1
        problem = new DefaultProblem(null, null, null, Integer.MIN_VALUE, -1, null);
        assertEquals(Integer.MIN_VALUE, problem.getLineNumber());
    }

    @Test
    void testGetColumnNumber() {

    private final Integer buildNumber;

    RemoteSnapshotMetadataGenerator(RepositorySystemSession session, DeployRequest request) {
        timestamp = (Date) ConfigUtils.getObject(session, new Date(), "maven.startTime");
        Object bn = ConfigUtils.getObject(session, null, "maven.buildNumber");
        if (bn instanceof Integer) {
            this.buildNumber = (Integer) bn;
        } else if (bn instanceof String) {

    private final Integer buildNumber;

    RemoteSnapshotMetadata(Artifact artifact, Date timestamp, Integer buildNumber) {
        super(createRepositoryMetadata(artifact), null, timestamp);
        this.buildNumber = buildNumber;
    }

    private RemoteSnapshotMetadata(Metadata metadata, Path path, Date timestamp, Integer buildNumber) {
        super(metadata, path, timestamp);

                information,
                defaultTypeRegistry,
                versionScheme,
                Collections.emptyMap(),
                Collections.emptyMap());

        int connectionTimeout = (Integer) systemSessionFactory
                .newRepositorySession(request)
                .getConfigProperties()
                .get(ConfigurationProperties.CONNECT_TIMEOUT + "." + server.getId());

         * is interested in, i.e. all phases up to and including the specified phase.
         */

        Map<String, Map<Integer, List<MojoExecution>>> mappings = new LinkedHashMap<>();

        for (String phase : lifecycle.getPhases()) {
            Map<Integer, List<MojoExecution>> phaseBindings = new TreeMap<>();

            mappings.put(phase, phaseBindings);

            if (phase.equals(lifecyclePhase)) {

        assertEquals("4.0.0", project4.getModelVersion());

        Build build = project4.getBuild();
        List<Plugin> plugins = build.getPlugins();

        Map<String, Integer> validPluginCounts = new HashMap<>();

        String testPluginArtifactId = "maven-compiler-plugin";

        // this is the plugin we're looking for.
        validPluginCounts.put(testPluginArtifactId, 0);

 */
// TODO Kristian wonders if this class really is necessary and if it overlaps other concepts.
public final class ProjectIndex {

    private final Map<String, MavenProject> projects;

    private final Map<String, Integer> indices;

    public ProjectIndex(List<MavenProject> projects) {
        this.projects = new HashMap<>(projects.size() * 2);
        this.indices = new HashMap<>(projects.size() * 2);

            String s = policy.substring(UPDATE_POLICY_INTERVAL.length() + 1);
            return Integer.parseInt(s);
        } else {
            return Integer.MAX_VALUE;
        }
    }

                }
                validateStringNotEmpty(problems, "proxies.proxy.host", proxy.getHost(), proxy.getId());

                try {
                    Integer.parseInt(proxy.getPortString());
                } catch (NumberFormatException e) {
                    addViolation(
                            problems,
                            BuilderProblem.Severity.ERROR,