if (min_max_statistics_.global_min() == std::numeric_limits<float>::max())
    return std::nullopt;

  CalibrationStatistics statistics;
  statistics.mutable_min_max_statistics()->CopyFrom(min_max_statistics_);

  return statistics;
}

}  // namespace calibrator

            .includeEngines("targetIncludedCategory")
            .excludeEngines("targetExcludedCategory")
            .includeTags("targetIncludedTag")
            .excludeTags("targetExcludedTag")
        target.copyFrom(source)

        then:
        with(target) {
            includeEngines =~ ["sourceIncludedCategory"]
            excludeEngines =~ ["sourceExcludedCategory"]
            includeTags =~ ["sourceIncludedTag"]

    private Set<String> excludeCategories = new LinkedHashSet<String>();

    /**
     * Copies the options from the source options into the current one.
     * @since 8.0
     */
    public void copyFrom(JUnitOptions other) {
        replace(this.includeCategories, other.includeCategories);
        replace(this.excludeCategories, other.excludeCategories);
    }

        val dir = readFile()
        val patterns = read() as PatternSet
        val tree = fileCollectionFactory.fileTree()
        tree.setDir(dir)
        // TODO - read patterns directly into tree
        tree.patterns.copyFrom(patterns)
        return tree
    }

CalibrationStatisticsCollectorAverageMinMax::GetStatistics() const {
  if (average_min_max_statistics_.num_samples() == 0) return std::nullopt;

  CalibrationStatistics statistics;
  statistics.mutable_average_min_max_statistics()->CopyFrom(
      average_min_max_statistics_);

  return statistics;
}

}  // namespace calibrator

  tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}

]]

  tuple& operator=(const tuple& t) { return CopyFrom(t); }

  template <GTEST_$(k)_TYPENAMES_(U)>
  tuple& operator=(const GTEST_$(k)_TUPLE_(U)& t) {
    return CopyFrom(t);
  }

$if k == 2 [[
  template <typename U0, typename U1>
  tuple& operator=(const ::std::pair<U0, U1>& p) {
    f0_ = p.first;

                distributionZip.delete()
                gradleHomeDir.deleteDir()

                URL url = getDownloadURL();
                System.out.println("downloading $url")
                distributionZip.copyFrom(url)

                System.out.println("unzipping ${distributionZip} to ${gradleHomeDir}")
                distributionZip.usingNativeTools().unzipTo(versionDir)

                markerFile.createFile()
            }

            nestedVisitor.visitFileTree(dir, sourcePatterns, o)
        }
        1 * sourcePatterns.intersect() >> intersectPatterns
        1 * intersectPatterns.copyFrom(patterns)
        1 * visitor.visitFileTree(dir, intersectPatterns, owner)
        0 * _
    }

    def "applies filters to mirror"() {
        def sourceMirror = Mock(DirectoryFileTree)

    def copyFromOverridesOldOptions() {
        given:
        def source = testNGOptionsWithPrefix("source", false, 0)

        when:
        def target = testNGOptionsWithPrefix("target", true, 5)
        target.copyFrom(source)

        then:
        with(target) {
            outputDirectory == source.outputDirectory
            includeGroups == source.includeGroups
            excludeGroups == source.excludeGroups

    TestFile createDistribution(int i) {
        def distro = temporaryDistributionFolder.file("distro$i")
        distro.deleteDir()

        distro.copyFrom(getTargetDist().getGradleHomeDir())
        distro.file("bin", OperatingSystem.current().getScriptName("gradle")).permissions = 'rwx------'
        distro.file("init.d/init.gradle") << """
            gradle.allprojects {