new org.eclipse.aether.graph.Dependency(RepositoryUtils.toArtifact(artifact), "compile"));
        pd.setDependencyNode(node);

        MojoDescriptor md = new MojoDescriptor();
        md.setGoal("my-goal");
        md.setPluginDescriptor(pd);

        pd.addComponentDescriptor(md);

        return new DefaultMojoExecution(

            public class FeatureTest {
                @Test
                public void shouldCompileAndRun() {
                    Complex complex = new Complex(2.0, 1);
                    assertEquals(3, complex.pow(2.0).getReal(), 1e-5);
                }
            }
        """

        when:

    private PluginExecution pluginGoal(String goalName, Plugin plugin) {
        if (plugin == null) {
            return null;
        }
        return plugin.getExecutions().stream().filter(exec ->
            exec.getGoals().stream().anyMatch(gl -> gl.startsWith(goalName))
        ).findFirst().orElse(null);
    }

    boolean packagesSources(MavenProject project) {
        Plugin sourcePlugin = plugin("maven-source-plugin", project);

	avg     time.Duration
	peak    time.Duration
	N       int64
}

func (l *latencyStat) update(d time.Duration) {
	l.lastmin.add(d)
	l.N++
	if d > l.peak {
		l.peak = d
	}
	l.curr = l.lastmin.getTotal().avg()
	l.avg = time.Duration((int64(l.avg)*(l.N-1) + int64(l.curr)) / l.N)
}

// epHealth struct represents health of a replication target endpoint.
type epHealth struct {
	Endpoint        string

            buf.append("\"query_time\":").append(suggestResponse.getTookMs());
            buf.append(",\"record_count\":").append(suggestResponse.getTotal());
            buf.append(",\"page_size\":").append(suggestResponse.getNum());

            if (!suggestResponse.getItems().isEmpty()) {
                buf.append(",\"data\":[");

}

// total returns the total call count and latency for the last minute.
func (e *lockedLastMinuteLatency) total() AccElem {
	e.mu.Lock()
	defer e.mu.Unlock()
	return e.lastMinuteLatency.getTotal()
}

func newXLStorageDiskIDCheck(storage *xlStorage, healthCheck bool) *xlStorageDiskIDCheck {
	xl := xlStorageDiskIDCheck{
		storage:      storage,
		health:       newDiskHealthTracker(),

        }
        fileDownloadListeners.getSource().statusChanged(new DefaultStatusEvent(
            progressEvent.getEventTime(),
            descriptor,
            progressEvent.getTotal(),
            progressEvent.getProgress(),
            progressEvent.getUnits()));
    }

    private void broadcastTaskProgressEvent(InternalProgressEvent event, InternalTaskDescriptor descriptor) {

					})
				}
			}
			ml = append(ml, MetricV2{
				Description: getClusterReplProxiedGetOperationsMD(clusterMetricNamespace),
				Value:       float64(m.Proxied.GetTotal),
			})
			ml = append(ml, MetricV2{
				Description: getClusterReplProxiedHeadOperationsMD(clusterMetricNamespace),
				Value:       float64(m.Proxied.HeadTotal),
			})
			ml = append(ml, MetricV2{

			cmds := cleanFlagSet.Args()
			if len(cmds) > 0 {
				return fmt.Errorf("unknown command %+s", cmds[0])
			}

			// short-circuit on help
			help, err := cleanFlagSet.GetBool("help")
			if err != nil {
				return errors.New(`"help" flag is non-bool, programmer error, please correct`)
			}
			if help {
				return cmd.Help()
			}

			// short-circuit on verflag

Calls to `BuildCacheConfiguration.local(Class)` with anything other than `DirectoryBuildCache` as the type will fail the build.
Calling these methods with the `DirectoryBuildCache` type will produce a deprecation warning.

Use `getLocal()` and `local(Action)` instead.

==== Failing to pack or unpack cached results will now fail the build