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)
	})

    }

    @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

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:

        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) {

        operationParamsBuilder.setInjectedPluginClasspath(classpath);
        return getThis();
    }

    public void copyFrom(ConsumerOperationParameters operationParameters) {
        operationParamsBuilder.copyFrom(operationParameters);
    }

  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;

    }

    def recompilesDependentClasses() {
        given:
        run("classes")

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

        then:
        runAndFail("classes").assertHasDescription("Execution failed for task ':compileScala'.")
    }

    @Issue("gradle/gradle#13392")