import org.junit.Test
import spock.lang.Issue


class UnitCodecTest : AbstractUserTypeCodecTest() {

    @Test
    @Issue("https://github.com/gradle/gradle/issues/25560")
    fun `same Unit instance is used upon restore`() {
        configurationCacheRoundtripOf(Unit).run {
            assertThat(this, sameInstance(Unit))
        }
    }

    port: {{.Port}}
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: Same
  - name: {{.Service}}-svc
    hostname: {{.Service}}.{{.Namespace}}.svc
    port: {{.Port}}
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: Same
  - name: {{.Service}}-namespace
    hostname: {{.Service}}.{{.Namespace}}
    port: {{.Port}}
    protocol: HTTP

import javax.inject.Inject
import java.util.logging.Level

class ConfigurationCacheTaskSerializationIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "using a tasks from same project as 'files(#type)' input is allowed"() {
        file("copy1source.txt") << "Copy 1"
        file("copy2source.txt") << "Copy 2"

        buildFile << """
            def copy1 = tasks.register("copy1", Copy) {

     * For the test output directory, the rules are more complex and are governed by the fact that
     * Java does not accept the placement of two modules of the same name on the module-path.
     * So the modular test output directory usually needs to be placed in a {@code --path-module} option.
     *
     * <ul>
     *   <li>If the test output directory is modular, then:

     *
     * <p>This method is used when testing iterators without a known ordering. We poll the target
     * iterator's next element and pass it to the reference iterator through this method so it can
     * return the same element. This enables the assertion to pass and the reference iterator to
     * properly update its state.
     */
    void promoteToNext(E e) {
      if (nextElements.remove(e)) {
        nextElements.push(e);

    def "intermediate model is cached and reused for nested concurrent requests"() {
        // Sleep to ensure concurrent requests for the same model catch up before the first one is finished
        withSomeToolingModelBuilderPluginInBuildSrc("""
            Thread.sleep(3000)
        """)

        settingsFile << """
            rootProject.name = "root"

interface CoupledProjectsListener {
    /**
     * Notified when the build logic for a [referrer] project accesses the mutable state of some other [target] project.
     *
     * The [referrer] and [target] might represent the same project, and the listener implementation
     * should handle this specifically, probably ignoring such calls, as a project is naturally coupled with itself.
     */

    def equalsAndHashCode() {
        when:
        DefaultResolvedDependency dependency = new DefaultResolvedDependency("config", newId("group", "name", "version"), buildOperationProcessor)
        DefaultResolvedDependency same = new DefaultResolvedDependency("config", newId("group", "name", "version"), buildOperationProcessor)

    def buildOperations = new BuildOperationsFixture(executer, testDirectoryProvider)

    def "load after store emits two realization operations with the same id"() {
        buildFile << """
            tasks.register("foo")
        """

        when:
        configurationCacheRun(":foo")
        then:

        if (availableClassifiers.map { it.scope }.hasScopeCloserThan(scopeForClass, element)) return false

        /**
         * If we have a property with the same name, avoid dropping qualifiers makes it reference a property with the same name e.g.,
         *    package my.component
         *    class foo { .. }  // A
         *    ..
         *    fun test() {
         *      val foo = ..    // B