assertTrue(reporting.unreportedProblemInCurrentCall(key2))
        assertFalse(reporting.unreportedProblemInCurrentCall(key1))
        assertFalse(reporting.unreportedProblemInCurrentCall(key2))

        reporting.leaveDynamicCall(entryPoint2)
        assertFalse(reporting.unreportedProblemInCurrentCall(key1))
        assertFalse(reporting.unreportedProblemInCurrentCall(key2))
    }

    @Test

        given:
        project.file('file') << "key2: value2"
        def manifest = convention.manifest {
            from 'file'
            attributes(key1: 'value1')
        }

        when:
        def mergedManifest = manifest.effectiveManifest

        then:
        manifest instanceof DefaultManifest
        mergedManifest.attributes as Map == [key1: 'value1', key2: 'value2', 'Manifest-Version': '1.0']
    }

                       whenMerged { classpath ->
                           classpath.entries.find { it.kind == 'src' && it.path == 'src/main/java' }.entryAttributes.key1 = 'value1'
                           classpath.entries.find { it.kind == 'src' && it.path == 'src/main/java' }.entryAttributes.key2 = 'value2'
                       }
                   }
               }
           }
        """
        file('src/main/java').mkdirs()

        }
    }

    @Test
    fun `can handle Hashtable`() {
        val hashtable = Hashtable<String, Any>(100)
        hashtable.put("key1", "value1")
        hashtable.put("key2", true)
        hashtable.put("key3", 42)
        configurationCacheRoundtripOf(hashtable).run {
            assertThat(hashtable, equalTo(this))
        }
    }

                       whenMerged { classpath ->
                           classpath.entries.find { it.kind == 'src' && it.path == 'src/main/java' }.entryAttributes.key1 = 'value1'
                           classpath.entries.find { it.kind == 'src' && it.path == 'src/main/java' }.entryAttributes.key2 = 'value2'
                       }
                   }
               }
           }
        """
        file('src/main/java').mkdirs()

        buildFile << """
            myTask.nested = [(providers.gradleProperty('key').get()): new NestedBean('value1'), key2: new NestedBean('value2')]
        """
        def taskPath = ':myTask'

        when:
        run taskPath, '-Pkey=key1'
        then:
        executedAndNotSkipped taskPath

        when:
        run taskPath, '-Pkey=key1'
        then:
        skipped taskPath

        when:

        VersionCatalogProblemId.TOML_SYNTAX_ERROR
    ])
    def "has multiple TOML parse errors"() {
        enableProblemsApiCheck()

        tomlFile << """
# missing key values
[plugins]
key=
key2=
"""

        when:
        fails 'help'

        then:
        verifyContains(failure.error, parseError {
            inCatalog('libs')

+5hd9AoQGORe5ifQU3vUWWZp4wNnFHbRy73IXeH4hW7tfdaW3iJPwUn9dA==
=Odlj
-----END PGP PUBLIC KEY BLOCK-----

pub    C1B12A5D99C0729D
uid    Valentin Fondaratov <******@****.***>

sub    606CC6C4533E81A2
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: BCPG v1.68

mQGNBGAic/4BDACtIv4a32pL+84jJNhJ1yb6GFgoWknJSJ6IELIL0Z7m+FYsymRs
lTJ/QwBgjZlgS3HS7IBhEl5o+kEt2/U5lPkz/krP8By8EvRv18PpfBzmXNT8rGqc

Louis Jacomet <******@****.***> 1711728981 +0100

        configurationCache.assertStateLoaded()
        outputContains("configurationCache.requested=true")
        outputContains("configurationCache.active=true")
    }

    def "not active even if requested due to --export-keys flag"() {
        def configurationCache = newConfigurationCacheFixture()

        buildFile """
            import org.gradle.api.configuration.BuildFeatures