for _, r := range modFile.Require {
		i.require[r.Mod] = requireMeta{indirect: r.Indirect}
	}

	i.replace = toReplaceMap(modFile.Replace)

	i.exclude = make(map[module.Version]bool, len(modFile.Exclude))
	for _, x := range modFile.Exclude {
		i.exclude[x.Mod] = true
	}

	return i
}

// modFileIsDirty reports whether the go.mod file differs meaningfully
// from what was indexed.

    }

    /**
     * Given an {@code other} {@code ImmutableFilteredList}, return a new list which contains all items in
     * this list, except with the item at the specified {@code index} in {@code other} excluded.
     * <p>
     * This method assumes that this list and {@code other} share the same source list.
     */
    public ImmutableFilteredList<T> withoutIndexFrom(int index, ImmutableFilteredList<T> other) {

        if (logger.isInfoEnabled()) {
            logger.info("Tasks to be executed: {}", graph.getAllTasks());
            logger.info("Tasks that were excluded: {}", ((TaskExecutionGraphInternal)graph).getFilteredTasks());
        }
    }

    @SuppressWarnings("deprecation")
    @Override
    public void buildFinished(BuildResult result) {
        this.action = result.getAction();

			return origlen, count, names
		}
		rec := buf[:reclen]
		buf = buf[reclen:]
		ino, ok := direntIno(rec)
		if !ok {
			break
		}
		// See src/os/dir_unix.go for the reason why this condition is
		// excluded on wasip1.
		if ino == 0 && runtime.GOOS != "wasip1" { // File absent in directory.
			continue
		}
		const namoff = uint64(unsafe.Offsetof(Dirent{}.Name))
		namlen, ok := direntNamlen(rec)

        when: //transitive dependency is excluded
        file("impl/build.gradle") << "configurations.implementation.exclude module: 'hamcrest-core' \n"
        run("impl:${language.compileTaskName}")

        then:
        file("impl/classpath.txt").text == wrapClassDirs("mockito-core-1.9.5.jar, junit-4.13.jar, objenesis-1.0.jar")

        when: //direct dependency is excluded

}

public class ATestNGClassWithGroups {
    @Test(groups="group1") public void group1() {}
    @Test(groups="group2") public void group2() {}
    @Test(groups="group2,group3") public void excluded() {}
    @Test(groups="group4") public void ignored() {}
}

public class ATestNGFactoryClass {
    @Factory
    public Object[] suite() {
        return [new ATestNGClass()] as Object[]
    }
}

        then:
        def e2 = thrown(TaskSelectionException)
        e2.message == message
            .replace("tasks that match", "excluded tasks that match")
            .replace("matching tasks", "matching excluded tasks")

        where:
        path        | message

      - G404
issues:
  # List of regexps of issue texts to exclude, empty list by default.
  # But independently from this option we use default exclude patterns,
  # it can be disabled by `exclude-use-default: false`. To list all
  # excluded by default patterns execute `golangci-lint run --help`
  exclude:
    - composite literal uses unkeyed fields
  # Which dirs to exclude: issues from them won't be reported.

     * @since 4.6
     */
    void setBranch(@Nullable String branch);

    /**
     * Sets the version as strict.
     * <p>
     * Any version not matched by this version notation will be excluded. This is the strongest version declaration.
     * It will cause dependency resolution to fail if no version acceptable by this clause can be selected.
     * This term supports dynamic versions.
     * <p>

	// understand nodes). For services that use externalTrafficPolicy=Local, this may mean that
	// any backends on excluded nodes are not reachable by those external load-balancers.
	// Implementations of this exclusion may vary based on provider.
	LabelNodeExcludeBalancers = "node.kubernetes.io/exclude-from-external-load-balancers"