then:
        action.execute(_) >> { Properties props ->
            props.remove('removed')
            props.changed = 'new'
            props.added = 'value'
        }
        props(changed:'new', added:'value') == result
    }

    def 'can use closure as action'() {
        given:
        transformer.addAction action { Properties props ->
            props.added = 'value'
        }
        when:

        T perform(Properties props);
    }

    interface WriteOpVoid {
        void perform(Properties props);
    }

    private <T> T writeOperation(WriteOp<T> runner) {
        Properties props = new Properties();
        props.putAll(getter.get());
        T ret = runner.perform(props);
        if (!props.equals(getter.get())) {
            setter.accept(props);
        }
        return ret;

		},
		MinioEnvVars: make(map[string]string, 10),
	}

	for poolNumber := range poolNumbers {
		props.PoolNumbers = append(props.PoolNumbers, poolNumber)
	}
	sort.Ints(props.PoolNumbers)
	props.PoolNumber = func() int {
		if len(props.PoolNumbers) == 1 {
			return props.PoolNumbers[0]
		}
		return math.MaxInt // this indicates that its unset.
	}()

	sensitive := map[string]struct{}{

     * </p>
     *
     * @param props
     *            プロパティセット。{@literal null}であってはいけません
     * @param in
     *            入力ストリーム。{@literal null}であってはいけません
     */
    public static void load(final Properties props, final InputStream in) {
        assertArgumentNotNull("props", props);
        assertArgumentNotNull("in", in);

        try {
            props.load(in);
        } catch (final IOException e) {

        Properties props = new Properties();
        props.put("key", "user_value");
        ToolchainModel toolchain = new ToolchainModel();
        toolchain.setType("TYPE");
        toolchain.setProvides(props);
        PersistedToolchains userResult = new PersistedToolchains();
        userResult.setToolchains(Collections.singletonList(toolchain));

        props = new Properties();

        expect:
        def object = parser.parseNotation([name: 'name', version: 'version', prop1: 'prop1', optional: '1.2'])
        object.key1 == 'name'
        object.key2 == 'version'
        object.prop1 == 'prop1'
    }

    def "does not mutate original map"() {
        def source = [name: 'name', version: 'version', prop1: 'prop1', optional: '1.2']
        def copy = new HashMap<String, Object>(source)

        when:

        osActivation.setOs( activationOS );

        osActivated.setActivation( osActivation );

        Properties props = System.getProperties();
        ProfileActivationContext ctx = new ProfileActivationContext( props, false );

        ProfileManager profileManager = new DefaultProfileManager( getContainer(), props );

        profileManager.addProfile( osActivated );

        List active = profileManager.getActiveProfiles( null );

        buildFile << """
            task props(type: WriteProperties) {
                outputFile = file("output.properties")
            }
        """

        when:
        runProps()
        then:
        file("output.properties").text == ""
    }

    def "empty properties with comment are written properly"() {
        given:
        buildFile << """
            task props(type: WriteProperties) {

        then:
        def props = daemonJvmPropertiesFile.properties
        props.size() == 3
        props[DaemonJvmPropertiesDefaults.TOOLCHAIN_VERSION_PROPERTY] == "11"
        props[DaemonJvmPropertiesDefaults.TOOLCHAIN_VENDOR_PROPERTY] == "IBM"
        props[DaemonJvmPropertiesDefaults.TOOLCHAIN_IMPLEMENTATION_PROPERTY] == "vendor-specific"

        def prop = details.getProperty('prop')
        prop.getters.size() == 2
        prop.setters.size() == 3
    }

    def "extracts properties from super class"() {
        expect:
        def details = ClassInspector.inspect(SubClass)

        details.propertyNames == ['class', 'metaClass', 'prop', 'readOnly', 'writeOnly', 'other'] as Set

        def prop = details.getProperty('prop')