return;
        }
        writeArray(key, () -> {
            for (ModuleMetadataSpec.Capability capability : capabilities) {
                writeObject(() -> {
                    write("group", capability.group);
                    write("name", capability.name);
                    if (capability.version != null) {
                        write("version", capability.version);
                    }
                });

        configureAction.execute(user);
    }

    @Override
    public ConfigurableUserClassFilePermissions getGroup() {
        return group;
    }

    @Override
    public void group(Action<? super ConfigurableUserClassFilePermissions> configureAction) {
        configureAction.execute(group);
    }

    @Override
    public ConfigurableUserClassFilePermissions getOther() {
        return other;
    }

    }

    @Override
    public String getProjectPath() {
        return null;
    }

    public String getGroup() {
        return group;
    }

    public LaunchableGradleTask setGroup(String group) {
        this.group = group;
        return this;
    }

    public boolean isPublic() {
        return isPublic;
    }

 * limitations under the License.
 */

package org.gradle.tooling.model;

/**
 * Informs about a module version, i.e. group, name, version.
 *
 * @since 1.1
 */
public interface GradleModuleVersion {

    /**
     * The group of the module, for example 'org.gradle'.
     */
    String getGroup();

    /**
     * The name of the module, for example 'gradle-tooling-api'.
     */
    String getName();

        description = "Initialize CI Pipeline by priming the cache before fanning out"
        group = ciGroup
        dependsOn(":base-services:createBuildReceipt")
    }

    register(sanityCheck) {
        description = "Run all basic checks (without tests) - to be run locally and on CI for early feedback"
        group = "verification"
        dependsOn(
            gradle.includedBuild("build-logic-commons").task(":check"),

  # cgroup v2: enable nesting
  if [ -f /sys/fs/cgroup/cgroup.controllers ]; then
    # move the processes from the root group to the /init group,
    # otherwise writing subtree_control fails with EBUSY.
    # An error during moving non-existent process (i.e., "cat") is ignored.
    mkdir -p /sys/fs/cgroup/init
    xargs -rn1 < /sys/fs/cgroup/cgroup.procs > /sys/fs/cgroup/init/cgroup.procs || :

// getCgroupSubsystemsV1 returns information about the mounted cgroup v1 subsystems
func getCgroupSubsystemsV1() (*CgroupSubsystems, error) {
	// get all cgroup mounts.
	allCgroups, err := libcontainercgroups.GetCgroupMounts(true)
	if err != nil {
		return &CgroupSubsystems{}, err
	}
	if len(allCgroups) == 0 {
		return &CgroupSubsystems{}, fmt.Errorf("failed to find cgroup mounts")
	}

/**
 * A dependency onto a module.
 */
@Incubating
public interface ModuleDependencySpec extends DependencySpec {

    /**
     * The group of the module this dependency specification refers to.
     *
     * @return the module group name
     */
    String getGroup();

    /**
     * The name of the module this dependency specification refers to.
     *
     * @return the module name
     */

            getCapability() >> cap
            getImplicitCapabilityProviders() >> []
        }
    }

    ComponentState component(String group="group", String name="name", String version="1.0") {
        ModuleIdentifier module = DefaultModuleIdentifier.newId(group, name)
        ModuleVersionIdentifier mvi = DefaultModuleVersionIdentifier.newId(module, version)
        Mock(ComponentState) {
            getId() >> mvi

        AbstractUserClassFilePermissions user = (AbstractUserClassFilePermissions) getUser();
        AbstractUserClassFilePermissions group = (AbstractUserClassFilePermissions) getGroup();
        AbstractUserClassFilePermissions other = (AbstractUserClassFilePermissions) getOther();
        return 64 * user.toUnixNumeric() + 8 * group.toUnixNumeric() + other.toUnixNumeric();
    }

    @SuppressWarnings("OctalInteger")