}
	sort.Stable(&byRFC6724{
		addrs:    addrs,
		addrAttr: addrAttr,
		srcs:     srcs,
		srcAttr:  srcAttr,
	})
}

// srcAddrs tries to UDP-connect to each address to see if it has a
// route. (This doesn't send any packets). The destination port
// number is irrelevant.
func srcAddrs(addrs []IPAddr) []netip.Addr {
	srcs := make([]netip.Addr, len(addrs))
	dst := UDPAddr{Port: 53}
	for i := range addrs {
		dst.IP = addrs[i].IP

}

plugins.withType<IdeaPlugin> {
    with(model) {
        module {
            testSources.from(smokeIdeTestSourceSet.java.srcDirs, smokeIdeTestSourceSet.groovy.srcDirs)
            testResources.from(smokeIdeTestSourceSet.resources.srcDirs)
        }
    }
}

tasks.register<SmokeIdeTest>("smokeIdeTest") {
    group = "Verification"
    maxParallelForks = 1

        def exe = components.exe
        with(exe.sources."$pluginName") {
            source.srcDirs*.name == ["d1", "d2"]
            exportedHeaders.srcDirs*.name == ["h1", "h2"]
        }

        def lib = components.lib
        with(lib.sources."$pluginName") {
            source.srcDirs*.name == ["d3"]
            exportedHeaders.srcDirs*.name == ["h3"]
        }
    }

                    source {
                        srcDirs "\$rootDir/modules/\${project.name}"
                        <% includedSourceCount.times { %>
                        include "src/src${it}_cpp.cpp"
                        <% } %>
                    }
                    exportedHeaders {
                        srcDirs "\$rootDir/modules/\${project.name}/src"
                        include "**/*.h"

                    source {
                        srcDirs "src/main/flat"
                        include "**/*.cpp"
                    }
                }
                c {
                    source {
                        srcDirs "src/main/flat"
                        include "**/*.c"
                    }
                    exportedHeaders {
                        srcDirs "src/main/flat"
                    }

apply plugin: 'java'

sourceSets {
    main {
        java { srcDirs = ['mainSources'] }
        resources { srcDirs = ['mainResources'] }
    }

    foo {
        java { srcDirs = ['fooSources'] }
        resources { srcDirs = ['fooResources'] }
    }

    test {
        java { srcDirs = ['testSources'] }
        resources { srcDirs = ['testResources'] }
    }

}
'''

        projectDir.create {

            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    sourceSets {
        main.java.srcDirs += 'src/main/kotlin'
        test.java.srcDirs += 'src/test/kotlin'
        androidTest.java.srcDirs += 'src/androidTest/kotlin'
    }
    testOptions {
        unitTests.returnDefaultValues = true
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }
}

        nested.srcDir 'dir1'

        when:
        set.srcDirs nested.sourceDirectories

        then:
        set.srcDirs == [testDir.file('dir1')] as Set

        when:
        nested.srcDir 'dir2'

        then:
        set.srcDirs == [testDir.file('dir1'), testDir.file('dir2')] as Set
    }

    void settingSourceDirsReplacesExistingContent() {

        def main = project.sourceSets.main
        main.antlr.srcDirs == [project.file('src/main/antlr')] as Set

        def test = project.sourceSets.test
        test.antlr.srcDirs == [project.file('src/test/antlr')] as Set

        when:
        project.sourceSets.create('custom')

        then:
        def custom = project.sourceSets.custom
        custom.antlr.srcDirs == [project.file('src/custom/antlr')] as Set
    }

    testImplementation 'junit:junit:4.13'
}

// tag::custom-source-locations[]
sourceSets {
    main {
        groovy {
            srcDirs = ['src/groovy']
        }
    }

    test {
        groovy {
            srcDirs = ['test/groovy']
        }
    }
}