fuzz.Fuzz(f, func(fg fuzz.Helper) {
		copyFrom := fuzz.Struct[*networking.TrafficPolicy](fg)

		empty1 := &networking.TrafficPolicy{}
		copied := mergeTrafficPolicy(empty1, copyFrom, true)
		assert.Equal(fg.T(), copyFrom, copied)

		empty2 := &networking.TrafficPolicy{}
		copied = mergeTrafficPolicy(empty2, copied, true)
		assert.Equal(fg.T(), copyFrom, copied)
	})

  tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}

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

  template <GTEST_1_TYPENAMES_(U)>
  tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
    return CopyFrom(t);
  }

  GTEST_DECLARE_TUPLE_AS_FRIEND_

  template <GTEST_1_TYPENAMES_(U)>
  tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
    f0_ = t.f0_;
    return *this;
  }

  T0 f0_;
};

    }

    @Test
    void recompilesDependentClasses() {
        executer.withTasks("classes").run();

        // Update interface, compile should fail
        file('src/main/groovy/IPerson.groovy').assertIsFile().copyFrom(file('NewIPerson.groovy'))

        ExecutionFailure failure = executer.withTasks("classes").runWithFailure();
        failure.assertHasDescription("Execution failed for task ':compileGroovy'.");
    }

    @Test

  tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}

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

  template <GTEST_1_TYPENAMES_(U)>
  tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
    return CopyFrom(t);
  }

  GTEST_DECLARE_TUPLE_AS_FRIEND_

  template <GTEST_1_TYPENAMES_(U)>
  tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
    f0_ = t.f0_;
    return *this;
  }

  T0 f0_;
};

public class Cursor {
    int col; // count from left of screen, 0 = left most
    int row; // count from bottom of screen, 0 = bottom most, 1 == 2nd from bottom

    @SuppressWarnings("ReferenceEquality")
    public void copyFrom(Cursor position) {
        if (position == this) {
            return;
        }
        this.col = position.col;
        this.row = position.row;
    }

    public void bottomLeft() {
        col = 0;

        where:
        row << ROWS
        col << COLS
    }

    def "move cursor to (#row,#col) when calling copyFrom on another cursor"() {
        given:
        Cursor cursor = Cursor.at(row, col)

        when:
        Cursor newCursor = new Cursor()
        newCursor.copyFrom(cursor)

        then:
        newCursor.row == cursor.row
        newCursor.col == cursor.col

        where:

                            field_tag { field: 5 }
                            field_tag { map_key { ui32: 123 } }
                          )pb"));
  RepeatedPtrField<FieldIndex> field_tags_sub;
  field_tags_sub.CopyFrom(field_tags);
  field_tags_sub.DeleteSubrange(2, 2);

  EXPECT_THAT(fieldTagMatches(field_tags_sub, field_tags), IsOkAndHolds(2));
}

TEST(FingerprintingTest, TestFieldTagMatchesNoninitialSubsequence) {

        action.execute(new AnsiContextImpl(ansi, colorMap, writePos));
        write(ansi);
    }

    private void charactersWritten(Cursor cursor, int count) {
        writeCursor.col += count;
        cursor.copyFrom(writeCursor);
    }

    private void newLineWritten(Cursor cursor) {
        writeCursor.col = 0;

        // On any line except the bottom most one, a new line simply move the cursor to the next row.

        when:
        def target = new JUnitOptions()
            .includeCategories("targetIncludedCategory")
            .excludeCategories("targetExcludedCategory")
        target.copyFrom(source)

        then:
        with(target) {
            includeCategories =~ ["sourceIncludedCategory"]
            excludeCategories =~ ["sourceExcludedCategory"]
        }
    }

        return mirror.filter(this.patterns);
    }

    @Override
    public MinimalFileTree filter(PatternFilterable patterns) {
        PatternSet filter = this.patterns.intersect();
        filter.copyFrom(patterns);
        return new FilteredMinimalFileTree(filter, tree);
    }

    @Override
    public void visitStructure(MinimalFileTreeStructureVisitor visitor, FileTreeInternal owner) {