public SetSystemProperties() {
        properties = new Properties();
        properties.putAll(System.getProperties());
    }

    public SetSystemProperties(Map<String, Object> properties) {
        this();
        customProperties.putAll(properties);
    }

    @Override
    public Statement apply(final Statement base, Description description) {
        return new Statement() {

import java.util.Hashtable
import java.util.Properties


class BaseTypeCodecTest : AbstractUserTypeCodecTest() {

    @Test
    fun `can handle Properties`() {
        val properties = Properties()
        properties.setProperty("prop1", "value1")
        properties.setProperty("prop2", "value2")
        configurationCacheRoundtripOf(properties).run {
            assertThat(properties, equalTo(this))
        }
    }

    private final Lazy<Map<String, Set<String>>> properties;

    private PropertiesBackedInstrumentationTypeRegistry(Supplier<Map<String, Set<String>>> properties) {
        this.properties = Lazy.locking().of(properties);
    }

    @Override
    public Set<String> getSuperTypes(String type) {
        return properties.get().getOrDefault(type, Collections.emptySet());
    }

    @Override

            );
        }

        try {
            Properties properties = new Properties();
            InputStream stream = resource.openStream();
            try {
                properties.load(stream);
            } finally {
                stream.close();
            }
            return properties;
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }

        final Properties prop = new Properties();
        lastModified = propertiesFile.lastModified();
        prop.load(inStream);
        properties = prop;
    }

    @Override
    public synchronized void load(final Reader reader) throws IOException {
        final Properties prop = new Properties();
        lastModified = propertiesFile.lastModified();

	}
	return recompMap[key]
}

func lookupInfoNFC(b input, i int) Properties {
	v, sz := b.charinfoNFC(i)
	return compInfo(v, sz)
}

func lookupInfoNFKC(b input, i int) Properties {
	v, sz := b.charinfoNFKC(i)
	return compInfo(v, sz)
}

// Properties returns properties for the first rune in s.
func (f Form) Properties(s []byte) Properties {
	if f == NFC || f == NFD {
		return compInfo(nfcData.lookup(s))
	}

        then:
        succeeds ':assertCodDisabled'
    }

    def "system property set on command line takes precedence over properties file"() {
        given:
        file('gradle.properties') << """
systemProp.mySystemProp=properties file
"""
        buildFile << """
task printSystemProp {
    doLast {
        println "mySystemProp=\${System.getProperty('mySystemProp')}"
    }
}
"""

    def "serializes serialized properties"() {
        def original = snapshot("x".bytes)
        write(original)

        expect:
        original == written
    }

    def "serializes string properties"() {
        def original = string("x")
        write(original)

        expect:
        original == written
    }

    def "serializes number properties"() {
        write(value)

import java.util.Map;
import java.util.Properties;
import java.util.function.Consumer;

public class DefaultPersistentDirectoryCache extends DefaultPersistentDirectoryStore implements ReferencablePersistentCache {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultPersistentDirectoryCache.class);

    private final Properties properties = new Properties();

// metadata.name and metadata.generateName properties are specified, making a shallow copy of the provided schema if needed.
func WithTypeAndObjectMeta(s *schema.Structural) *schema.Structural {
	if s.Properties != nil &&
		s.Properties["kind"].Type == "string" &&
		s.Properties["apiVersion"].Type == "string" &&
		s.Properties["metadata"].Type == "object" &&
		s.Properties["metadata"].Properties != nil &&