PatternSet other = new PatternSet()
        other.include 'a', 'b'
        other.exclude 'c'
        other.include({ true } as Spec)
        other.exclude({ false } as Spec)

        when:
        patternSet.copyFrom(other)

        then:
        patternSet.includes == ['a', 'b'] as Set
        patternSet.excludes == ['c'] as Set
        !patternSet.includes.is(other.includes)
        !patternSet.excludes.is(other.excludes)

    @UsedByScanPlugin("test-retry")
    @Override
    public TestFramework copyWithFilters(TestFilter newTestFilters) {
        TestNGOptions copiedOptions = objects.newInstance(TestNGOptions.class);
        copiedOptions.copyFrom(options);

        return new TestNGTestFramework(
            (DefaultTestFilter) newTestFilters,
            objects,
            testTaskTemporaryDir,
            htmlReport,
            copiedOptions,

  hist_stats.mutable_hist_freq()->Assign(hist_freq_.begin(),
                                         hist_freq_.begin() + real_size);

  CalibrationStatistics statistics;
  statistics.mutable_histogram_statistics()->CopyFrom(hist_stats);

  return statistics;
}

std::pair<int32_t, int32_t>
CalibrationStatisticsCollectorHistogram::ExpandHistogramIfNeeded(
    const float lower_bound, const float upper_bound) {

    }

    @UsedByScanPlugin("test-retry")
    @Override
    public TestFramework copyWithFilters(TestFilter newTestFilters) {
        JUnitOptions copiedOptions = new JUnitOptions();
        copiedOptions.copyFrom(options);

        return new JUnitTestFramework(
            (DefaultTestFilter) newTestFilters,
            useImplementationDependencies,
            copiedOptions,
            testTaskTemporaryDir,

    }

    @UsedByScanPlugin("test-retry")
    @Override
    public TestFramework copyWithFilters(TestFilter newTestFilters) {
        JUnitPlatformOptions copiedOptions = new JUnitPlatformOptions();
        copiedOptions.copyFrom(options);

        return new JUnitPlatformTestFramework(
            (DefaultTestFilter) newTestFilters,
            useImplementationDependencies,
            copiedOptions,
            dryRun
        );
    }

        // means the chunked_field is relevant and the necessary data should be
        // copied over.
        auto cf = std::make_unique<proto_splitter::ChunkedField>();
        cf->mutable_field_tag()->CopyFrom(chunked_field.field_tag());
        TF_ASSIGN_OR_RETURN(
            *cf->mutable_message(),
            PruneChunkedMessage(chunked_field.message(), reader, chunks_info,
                                target_fields_list));

    public File getDir() {
        return dir;
    }

    @Override
    public DirectoryFileTree filter(PatternFilterable patterns) {
        PatternSet patternSet = this.patternSet.intersect();
        patternSet.copyFrom(patterns);
        return new DirectoryFileTree(dir, patternSet, fileSystem, postfix);
    }

    @Override
    public boolean contains(File file) {

        given:
        dependency 'org.test:buildB:1.0'

        buildA.settingsFile << """
rootProject.buildFileName='build-copy.gradle'
"""

        buildA.file("build-copy.gradle").copyFrom(buildA.buildFile)

        when:

  // owns the underlying memory. This could be a .deepcopy()/clone() method.

  // TODO(bmzhao): In the future, we want to relax the non-copyability
  // constraint. To do so, we can add a C API function that acts like
  // CopyFrom:
  // https://github.com/tensorflow/tensorflow/blob/08931c1e3e9eb2e26230502d678408e66730826c/tensorflow/core/framework/tensor.h#L301-L311

  // Tensor is movable, but not copyable
  Tensor(Tensor&&) = default;

        EmptyTensor(static_cast<TF_DataType>(src.dtype()), src.shape());
    auto* ret = emptyTensor->tensor;
    delete emptyTensor;
    return ret;
  }

  Tensor tensor;
  if (!tensor.CopyFrom(src, src.shape())) {
    return nullptr;
  }
  return new tensorflow::TensorInterface(std::move(tensor));
}

// Non-static for testing.