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();

        this.type = type;
        this.parent = parent;
        this.parentImports = parentImports;
        this.foreignImports = foreignImports;
        this.constituents = constituents;
    }

    public RealmType getType() {
        return type;
    }

    public ClassLoader getParent() {
        return parent;
    }

    public List<String> getImports() {

        }

        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("..");

    }

    private fun getContainingCallExpression(argument: KtValueArgument): KtCallExpression? {
        return when (val parent = argument.parent) {
            is KtCallExpression -> parent
            is KtValueArgumentList -> parent.parent as? KtCallExpression
            else -> null
        }
    }

    override fun isDefinitelyNull(expression: KtExpression): Boolean {

        MavenProject project = getMavenProject(artifactId);
        Parent parent = new Parent();
        parent.setGroupId(parentProject.getGroupId());
        parent.setArtifactId(parentProject.getArtifactId());
        project.getModel().setParent(parent);
        return project;
    }

    private MavenProject getMavenProject(String artifactId) {

<project xmlns="http://maven.apache.org/POM/4.0.0">

    <parent>
        <groupId>org.apache.maven.ut</groupId>
        <artifactId>parent</artifactId>
    </parent>
    <artifactId>dep</artifactId>

import org.apache.maven.api.model.Parent;

/**
 * Resolves a POM from its coordinates.
 */
public interface ModelResolver extends Service {

    /**
     * Tries to resolve the POM for the specified parent coordinates possibly updating {@code parent}.
     *
     * @param session The session to use to resolve the model, must not be {@code null}.
     * @param parent The parent coordinates to resolve, must not be {@code null}.

    }

    /**
     * Tests whether local version range parent references are build correctly.
     *
     * @throws Exception
     */
    public void testBuildParentVersionRangeLocallyWithChildProjectParentVersionExpression() throws Exception {
        File f1 = getTestFile(
                "src/test/resources/projects/parent-version-range-local-child-project-parent-version-expression/child/pom.xml");

        try {