given:
        resolveContext.hasDependencies() >> false

        when:
        def results = dependencyResolver.resolveGraph(resolveContext)

        then:
        results.visitedGraph.resolutionResult.rootSource.get().dependencies.empty

        def visitedArtifacts = results.visitedArtifacts
        def artifactSet = visitedArtifacts.select(Mock(ArtifactSelectionSpec))

import org.gradle.performance.fixture.PerformanceTestDirectoryProvider
import org.gradle.performance.results.DataReporter
import org.gradle.performance.results.DefaultOutputDirSelector
import org.gradle.performance.results.GradleProfilerReporter
import org.gradle.performance.results.OutputDirSelector
import org.gradle.performance.results.PerformanceTestResult
import org.gradle.profiler.flamegraph.DifferentialStacksGenerator

 */

package org.gradle.performance.results.report;

import org.gradle.performance.results.PerformanceExperiment;
import org.gradle.performance.results.PerformanceFlakinessDataProvider;
import org.gradle.performance.results.PerformanceReportScenario;
import org.gradle.performance.results.PerformanceTestExecutionResult;
import org.gradle.performance.results.ResultsStore;
import org.gradle.performance.results.ResultsStoreHelper;

import org.gradle.internal.time.Clock
import org.gradle.internal.time.Time
import org.gradle.performance.results.CrossBuildPerformanceResults
import org.gradle.performance.results.DataReporter
import org.gradle.performance.results.ResultsStoreHelper
import org.gradle.profiler.BuildMutator
import org.gradle.profiler.InvocationSettings
import org.junit.Assume

        readClass2.startTime == 5678
        readClass2.results.empty
    }

    List<TestClassResult> serialize(Collection<TestClassResult> results) {
        def serializer = new TestResultSerializer(tmp.createDir("results"))
        serializer.write(results)
        def result = []
        serializer.read({ result << it } as Action)
        return result
    }

				creds:           opts.creds,
			}

			results := globalNotificationSys.SpeedTest(ctx, sopts)
			sort.Slice(results, func(i, j int) bool {
				return results[i].Endpoint < results[j].Endpoint
			})

			totalPut := uint64(0)
			totalGet := uint64(0)
			for _, result := range results {
				totalPut += result.Uploads
				totalGet += result.Downloads
			}

			if totalGet < throughputHighestGet {

    final String version
    final MeasuredOperationList results = new MeasuredOperationList()

    BaselineVersion(String version) {
        this.version = version
        results.name = "Gradle $version"
    }

    String getSpeedStatsAgainst(String displayName, MeasuredOperationList current) {
        def sb = new StringBuilder()
        def thisVersionMean = results.totalTime.median

 * limitations under the License.
 */

package org.gradle.performance.results.report;

import com.google.common.collect.ImmutableList;
import org.gradle.performance.results.CrossBuildPerformanceTestHistory;
import org.gradle.performance.results.PerformanceReportScenario;
import org.gradle.performance.results.PerformanceTestExecutionResult;
import org.gradle.performance.results.PerformanceTestExecution;

  std::vector<tfrt::RCReference<tfrt::AsyncValue>> results;
  results.resize(func->result_types().size());
  std::vector<tfrt::RCReference<tfrt::AsyncValue>> result_tensors;
  result_tensors.resize(func->result_types().size() - 1);

  func->Execute(exec_ctx, arguments.values(), results);
  host->Await(results);

  for (auto& result : results) {
    EXPECT_FALSE(result->IsError());
  }
}

    }

    @CompileStatic
    private static class CurrentVersionResults implements VersionResults {
        final MeasuredOperationList results

        CurrentVersionResults(MeasuredOperationList results) {
            this.results = results
        }
    }