}

        @Override
        public Object[] toArray() {
            return parent.toArray();
        }

        @Override
        public <T> T[] toArray(final T[] a) {
            return parent.toArray(a);
        }

        @Override
        public boolean add(final E e) {
            return parent.add(e);
        }

        @Override

        final Parent parent = Parent.newBuilder()
                .groupId("org.apache")
                .artifactId("apache")
                .version("1")
                .build();

        assertNotNull(this.newModelResolver().resolveModel(session, parent, new AtomicReference<>()));
        assertEquals("1", parent.getVersion());
    }

    @Test

        private final SearchRequestParams parent;
        private final int startPosition;
        private final int pageSize;

        SearchRequestParamsWrapper(final SearchRequestParams parent, final int startPosition, final int pageSize) {
            this.parent = parent;
            this.startPosition = startPosition;
            this.pageSize = pageSize;
        }

        parent.setArtifactId("apache");
        parent.setVersion("1");

        assertNotNull(this.newModelResolver().resolveModel(parent.getDelegate(), new AtomicReference<>()));
        assertEquals("1", parent.getVersion());
    }

    @Test
    void testResolveParentSuccessfullyResolvesExistingParentUsingHighestVersion() throws Exception {
        final Parent parent = new Parent();
        parent.setGroupId("org.apache");

        var parent = parent
        while (parent is KtDotQualifiedExpression) {
            if (parent.selectorExpression !== this) return true
            parent = parent.parent
        }
        return false
    }

    private fun KtSimpleNameExpression.isPartOfUserTypeRefQualifier(): Boolean {
        var parent = parent
        while (parent is KtUserType) {

import com.google.common.base.CaseFormat;

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;
        }

        builder = Model.newBuilder(model);
        modelMerger.mergeModel_ModelVersion(builder, model, parent, false, null);
        assertEquals("5.0.0", builder.build().getModelVersion());
    }

    // ArtifactId is neither inherited nor injected
    @Test
    void testMergeModel_ArtifactId() {
        Model parent = Model.newBuilder().artifactId("PARENT").build();
        Model model = Model.newInstance();

                (parent.expression == child && isUsed(parent.parent)) || child in parent.conditions

            is KtWhenCondition ->
                doesParentUseChild(parent.parent, parent)

            // Type parameters, return types and other annotations are all contained in KtUserType,
            // and are never considered used as expressions
            is KtUserType ->
                false

        }

        public <T> T[] toArray(final T[] a) {
            return parent.toArray(a);
        }

        public boolean add(final E e) {
            return parent.add(e);
        }

        public boolean remove(final Object o) {
            return parent.remove(o);
        }

        public boolean containsAll(final Collection<?> c) {
            return parent.containsAll(c);

        }
    }

    //
    // Infer parent information
    //
    void handleParent(ModelTransformerContext context, Model model, Path pomFile, Model.Builder builder) {
        Parent parent = model.getParent();
        if (parent != null) {
            String version = parent.getVersion();
            String path = Optional.ofNullable(parent.getRelativePath()).orElse("..");