file("local.properties") << "\nunrelated.properties=foo"
        configurationCacheRun "run"

        then:
        output.count("ON CI") == 1
        configurationCache.assertStateLoaded()

        when: "running after changing the property value"
        file("local.properties").text = "ci=false"
        configurationCacheRun "run"

        then:

	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = new(NestedValueValidation)
		(*in).DeepCopyInto(*out)
	}
	if in.Properties != nil {
		in, out := &in.Properties, &out.Properties
		*out = make(map[string]NestedValueValidation, len(*in))
		for key, val := range *in {
			(*out)[key] = *val.DeepCopy()
		}
	}
	if in.AdditionalProperties != nil {

						<networkaddress.cache.negative.ttl>-1</networkaddress.cache.negative.ttl>
					</systemPropertyVariables>
					<properties>
						<property>
							<name>listener</name>
							<value>jcifs.tests.PrintingRunListener</value>
						</property>
					</properties>
					<useSystemClassLoader>false</useSystemClassLoader>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.jacoco</groupId>

    }

    @Test
    void testSystemScopeDependencyIsPresentInTheCompileClasspathElements() throws Exception {
        File pom = getProject("it0063");

        Properties eps = new Properties();
        eps.setProperty("jre.home", new File(pom.getParentFile(), "jdk/jre").getPath());

        MavenSession session = createMavenSession(pom, eps);
        MavenProject project = session.getCurrentProject();

        def jdk17 = AvailableJavaHomes.getJdk17()

        file("gradle.properties").writeProperties("org.gradle.java.home": jdk21.javaHome.absolutePath)
        withConnection { connection ->
            connection.newBuild().forTasks('help').run()
        }

        file("gradle.properties").writeProperties("org.gradle.java.home": jdk17.javaHome.absolutePath)
        withConnection { connection ->

        } else if (targetVersion >= GradleVersion.version("6.8")) {
            return ['buildEnvironment', 'components', 'dependencies', 'dependencyInsight', 'dependentComponents', 'help', 'javaToolchains', 'projects', 'properties', 'tasks', 'model', 'outgoingVariants']

        false
    }
}

abstract class AbstractToolingApiPropertiesLoaderCrossVersionSpec extends ToolingApiSpecification {

    @Issue('https://github.com/gradle/gradle/issues/11173')
    def "System properties defined in gradle.properties are available in buildSrc and in included builds"() {
        setup:
        settingsFile << '''
            includeBuild 'includedBuild'

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.properties.annotations;

import org.gradle.api.problems.internal.GradleCoreProblemGroup;
import org.gradle.internal.reflect.annotations.PropertyAnnotationMetadata;
import org.gradle.internal.reflect.validation.TypeValidationContext;

    }

    private static Map<String, String> convertSystemProperties(Properties properties) {
        Map<String, String> result = new HashMap<String, String>();
        for (Map.Entry<Object, Object> entry : properties.entrySet()) {
            result.put(entry.getKey().toString(), entry.getValue() == null ? null : entry.getValue().toString());
        }

    val schema = schemaFromTypes(HasHiddenProperty::class, listOf(HasHiddenProperty::class))

    @Test
    fun `handles the hidden properties correctly`() {
        val aType = schema.dataClassesByFqName.getValue(DefaultFqName.parse(HasHiddenProperty::class.qualifiedName!!))
        assertTrue { aType.properties.single { it.name == "y" }.isHiddenInDsl }

        val result = schema.resolve(
            """
            x = 1
            y = 2