publishArtifactDependencies.getDependencies(task) >> [task]

        then:
        publication.publishableArtifacts.files.buildDependencies.getDependencies(task).contains(task)
    }

    def "multiple usages of a component can provide the same artifact"() {
        given:
        def publication = createPublication()
        def artifact1 = Mock(PublishArtifact)
        artifact1.file >> artifactFile

	}

	for _, usage := range usages {
		if usage == nil {
			continue
		}
		unit := usage.GetUnit()
		switch unit {
		case csipbv1.VolumeUsage_BYTES:
			metrics.Available = resource.NewQuantity(usage.GetAvailable(), resource.BinarySI)
			metrics.Capacity = resource.NewQuantity(usage.GetTotal(), resource.BinarySI)
			metrics.Used = resource.NewQuantity(usage.GetUsed(), resource.BinarySI)

        }
    }
}

/**
 * Registers services which are not covered by [FirStandaloneServiceRegistrar]. In general, this concerns services which need to be
 * registered for production Standalone and Standalone test usages, but *not* for IDE mode Analysis API tests, which rely on
 * [FirStandaloneServiceRegistrar] as a basis.
 *

  let summary = "Removes `stablehlo.custom_call @Sharding`";
  let description = [{
    Finds `stablehlo.custom_call @Sharding` and removes all instances of them,
    replacing the usages by its operand. This is used where sharding doesn't
    make much sense or sharding custom calls are incompatible, e.g. on-device
    targets.
  }];
  let dependentDialects = ["mlir::stablehlo::StablehloDialect"];
}

        }
    }
}
"""
        if (mapping) {
            extra = """
project(":project1") {
    publishing {
        publications.maven {
            versionMapping {
                usage(Usage.JAVA_API) {
                    fromResolutionResult()
                }
            }
        }
    }
}
""" + extra
        }
        createBuildScripts(extra)

        when:

    //  We cannot use this syntax until adopting JSpecify with e.g. Jetbrains Annotations, because IDEA wrongly treats all usages as having a nullable type, even when
    //  it is explicitly spelled.

    private final DisplayName displayName;

   * 2. Tests on hardcoded datasets include non-finite values for chains starting with scale(10);
   * 3. Tests on a mechanically generated dataset for chains starting with percentiles();
   * 4. Tests of illegal usages of the API.
   */

  /*
   * Covering every combination would lead to an explosion in the number of tests. So we cover only:
   * - median with compute taking a double-collection and with computeInPlace;

    //  We cannot use this syntax until adopting JSpecify with e.g. Jetbrains Annotations, because IDEA wrongly treats all Try usages as having a nullable type, even when
    //  it is explicitly spelled, e.g.
    //  Try<String> t = Try.successful("some")

  new_if_op.getThenBranch().push_back(new Block);
  new_if_op.getElseBranch().push_back(new Block);

  // Replace internal usages of merged if ops.
  ReplaceInternalUsage(if_op_segment);

  // Replace external usages of merged if ops.
  ReplaceExternalUsage(if_op_segment, new_if_op, return_indices);

  // Move ops after the new merged If region.

```

To make old plugins compatible we need to replace all the usages of old JavaCompile with the new one.

Let’s say it’s used in a plugin as:

```java
public void applyPlugin(Project project) {
     project.tasks.named("compileJava", JavaCompile.class, task -> {
         task.setSourceCompatibility("1.8");
     });
}
```

We will then replace all such usages with interception code:
```java