import com.esotericsoftware.kryo.io.Output;
import com.google.common.collect.Maps;
import org.gradle.internal.serialize.AbstractEncoder;
import org.gradle.internal.serialize.FlushableEncoder;

import javax.annotation.Nullable;
import java.io.Closeable;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Map;

    public ModelProperty(ModelType<T> type, String name, Set<ModelType<?>> declaredBy,
                         Map<PropertyAccessorType, WeaklyTypeReferencingMethod<?, ?>> accessors) {
        this.name = name;
        this.type = type;
        this.declaredBy = ImmutableSet.copyOf(declaredBy);
        this.accessors = Maps.immutableEnumMap(accessors);
    }

    public String getName() {
        return name;
    }

		if !ok {
			continue
		}
		if waypointServices.services == nil {
			waypointServices.services = map[host.Name]*model.Service{}
		}
		waypointServices.services[hostName] = svc
	}

	unorderedServices := maps.Values(waypointServices.services)
	if len(serviceInfos) > 0 {
		waypointServices.orderedServices = model.SortServicesByCreationTime(unorderedServices)
	}

import com.google.common.collect.ImmutableSortedMap;
import com.google.common.collect.Maps;
import org.gradle.internal.Cast;
import org.gradle.model.internal.manage.schema.extract.ModelSchemaAspect;
import org.gradle.model.internal.method.WeaklyTypeReferencingMethod;
import org.gradle.model.internal.type.ModelType;

import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;

func gatewayPodsLabelMap(context analysis.Context) map[string][]map[string]string {
	pods := make(map[string][]map[string]string)
	context.ForEach(gvk.Pod, func(resource *resource.Instance) bool {
		if _, ok := resource.Metadata.Labels[constants.GatewayNameLabel]; !ok {
			return true
		}
		ns := resource.Metadata.FullName.Namespace.String()
		pods[ns] = append(pods[ns], resource.Metadata.Labels)
		return true
	})
	return pods

    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testEquals() {
    resetContainer(
        Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k1(), v0()), Helpers.mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = Maps.newHashMap();
    expected.put(k0(), Lists.newArrayList(v0(), v3()));
    expected.put(k1(), Lists.newArrayList(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testEquals() {
    resetContainer(
        Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k1(), v0()), Helpers.mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = Maps.newHashMap();
    expected.put(k0(), Lists.newArrayList(v0(), v3()));
    expected.put(k1(), Lists.newArrayList(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

    }

    private static class StrictCapabilityMapNotationParser extends MapNotationConverter<Capability> {
        @Override
        public void describe(DiagnosticsVisitor visitor) {
            visitor.candidate("Maps").example("[group: 'org.group', name: 'capability', version: '1.0']");
        }

        protected Capability parseMap(@MapKey("group") String group,
                                      @MapKey("name") String name,

     *
     * A result is only calculated once.
     */
    T completeAndGet();

    /**
     * Maps the result of the invocation via a mapper.
     *
     * @param mapper An inexpensive function on the result.
     * @throws NullPointerException if the mapper maps to {@code null}.
     */
    default <U> Deferrable<U> map(Function<? super T, U> mapper) {
        return new Deferrable<U>() {
            @Override

	// // the generic type StringInt[T], which maps directly to T.
	// got2 := stringify(x2)
	// want2 := []string{"5", "7", "6"}
	// if !reflect.DeepEqual(got2, want2) {
	// 	panic(fmt.Sprintf("got %s, want %s", got2, want2))
	// }

	// stringify on an instantiated type, whose bound method is associated with
	// the generic type StringStruct[T], which maps to a struct containing T.