},
			want: []model.ConfigHash{
				model.ConfigKey{
					Kind:      kind.VirtualService,
					Name:      "foo",
					Namespace: "default",
				}.HashCode(),
			},
		},
		{
			name: "single parent",
			r: Cache{
				VirtualServices: []config.Config{
					{
						Meta: config.Meta{
							Name:      "foo-0-istio-autogenerated-k8s-gateway",
							Namespace: "default",

        flatten(s7) == [parent.path]
    }

    def "has a nice toString representation"() {
        def parent = tmpDir.createDir()
        def dir1 = parent.createDir("dir1")
        def dir2 = parent.createDir("common/dir2")
        def dir3 = parent.createDir("common/dir3")
        def set = from(dir1, dir2, dir3)

        expect:
        set.toString() == """
            ${parent.absolutePath}

      getElementTypeOrSelf(value.getType()));
}

bool HasOutsideCompiledAncestor(Operation* op) {
  Operation* parent = op->getParentOp();
  while (parent) {
    if (parent->getAttrOfType<StringAttr>(kXlaOutsideCompilationAttr))
      return true;
    parent = parent->getParentOp();
  }
  return false;
}

// If any tf.variants are inputs/outputs to the another outside compiled

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

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

        return parent.addAll(index, c);
    }

    @Override
    public void clear() {
        parent.clear();
    }

    @Override
    public boolean contains(final Object o) {
        return parent.contains(o);
    }

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

    @Override

	if fn(mn) {
		mn.Parent.Traverse(fn)
		mn.Name.Traverse(fn)
	}
}

func (mn *ModuleName) Copy(fn func(AST) AST, skip func(AST) bool) AST {
	if skip(mn) {
		return nil
	}
	var parent AST
	if mn.Parent != nil {
		parent = mn.Parent.Copy(fn, skip)
	}
	name := mn.Name.Copy(fn, skip)
	if parent == nil && name == nil {
		return fn(mn)
	}
	if parent == nil {

        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

        }

        @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

    @Issue("https://github.com/gradle/gradle/issues/12996")
    def "doesn't attempt to write in read-only cache if parent POM is missing from it"() {
        given:
        def parent = mavenHttpRepo.module('org.readonly', 'parent', '1.0')
        def other = mavenHttpRepo.module("org.other", "other", "1.0")
            .parent("org.readonly", "parent", "1.0").publish()
        buildFile << """
            dependencies {