env CGO_ENABLED=0
go list -f '{{range .GoFiles}}{{.}} {{end}}'
stdout 'empty.go suffix_linux.go tag.go'
go list -f '{{range .CgoFiles}}{{.}} {{end}}'
! stdout .
go list -f '{{range .Imports}}{{.}} {{end}}'
stdout '^suffix tag $'

# Changing OS should exclude linux sources.
env GOOS=darwin
go list -f '{{range .GoFiles}}{{.}} {{end}}'
stdout '^empty.go $'
go list -f '{{range .Imports}}{{.}} {{end}}'
stdout '^$'

type _ myInt /* ERROR "not a generic type" */ [] // ERROR "expected type argument list"

// TODO(gri) better error messages
type _ T1[] // ERROR "expected type argument list"
type _ T1[x /* ERROR "not a type" */ ]
type _ T1 /* ERROR "too many type arguments for type T1: have 2, want 1" */ [int, float32]

var _ T2[int] = T2[int]{}

var _ List[int] = []int{1, 2, 3}
var _ List[[]int] = [][]int{{1, 2, 3}}

                  ]
                }
              ],
              "verbs": [
                "create",
                "delete",
                "deletecollection",
                "get",
                "list",
                "patch",
                "update",
                "watch"
              ]
            }
          ],
          "version": "v1"
        }
      ]
    },
    {
      "metadata": {

        new ModelType<List<?>>() {}.hasWildcardTypeVariables
        new ModelType<List<? extends CharSequence>>() {}.hasWildcardTypeVariables
        new ModelType<List<? super CharSequence>>() {}.hasWildcardTypeVariables
        !new ModelType<List<List<String>>>() {}.hasWildcardTypeVariables
        new ModelType<List<List<?>>>() {}.hasWildcardTypeVariables
        new ModelType<List<List<List<?>>>>() {}.hasWildcardTypeVariables

    }

    // Tries to find the common super-group for a list of groups
    // For example given ["org.foo", "org.foo.bar", "org.foo.baz"] it will group using "org.foo.*"
    static List<List<String>> tryComputeCommonPrefixes(List<String> groups) {
        List<List<String>> splitGroups = groups.stream()
            .map(GROUP_SPLITTER::splitToList)
            .sorted(Comparator.comparing(List::size))
            .collect(Collectors.toList());

        return doBatchInsert(new BulkList<>(list, call, entityCall), null);
    }

    public int[] batchUpdate(List<WebConfig> list) {
        return batchUpdate(list, null, null);
    }

    public int[] batchUpdate(List<WebConfig> list, RequestOptionCall<BulkRequestBuilder> call) {
        return batchUpdate(list, call, null);
    }

    public int[] batchUpdate(List<WebConfig> list, RequestOptionCall<BulkRequestBuilder> call,

    private final List<TaskIdentity> finalizers;

    public DefaultPlannedTask(
        TaskIdentity taskIdentity,
        List<? extends NodeIdentity> nodeDependencies,
        List<TaskIdentity> mustRunAfter,
        List<TaskIdentity> shouldRunAfter,
        List<TaskIdentity> finalizers
    ) {
        this.taskIdentity = taskIdentity;
        this.nodeDependencies = nodeDependencies;
        this.mustRunAfter = mustRunAfter;

        final String name;
        final List<Attribute> attributes;
        final List<Capability> capabilities;
        final List<Dependency> dependencies;
        final List<DependencyConstraint> dependencyConstraints;
        final List<Artifact> artifacts;

        LocalVariant(
            String name,
            List<Attribute> attributes,
            List<Capability> capabilities,

    private final Map<ExternalResourceName, List<String>> directoriesToList = new HashMap<>();

    public ResourceVersionLister(ExternalResourceRepository repository) {
        this.repository = repository;
    }

    @Override
    public void listVersions(ModuleIdentifier module, IvyArtifactName artifact, List<ResourcePattern> patterns, BuildableModuleVersionListingResolveResult result) {
        List<String> collector = new ArrayList<>();

import java.io.Serializable;
import java.util.List;


public interface ClassToKClassParameterizedType<T extends Serializable> {

    T invariantClass(Class<T> type, List<T> list);

    T covariantClass(Class<? extends T> type, List<T> list);

    T contravariantClass(Class<? super T> type, List<T> list);

    <V extends T> V covariantMethodParameterizedInvariantClass(Class<V> type, List<V> list);