*/
    public Tuple3(final T1 value1, final T2 value2, final T3 value3) {
        this.value1 = value1;
        this.value2 = value2;
        this.value3 = value3;
    }

    /**
     * 1番目の値を返します。
     *
     * @return 1番目の値
     */
    public T1 getValue1() {
        return value1;
    }

    /**
     * 1番目の値を設定します。
     *
     * @param value1
     *            1番目の値
     */

        when:
        map.putAll(["first": "value1", "second": "value2", "third": "value3", "forth": "value4", "fifth": "value5"])
        map.retainAll { it.key in ["first", "third", "forth"] }

        then:
        mapProperty.get() == ["first": "value1", "third": "value3", "forth": "value4"]
    }

    def "contains operations work"() {
        given:
        mapProperty.put("first", "value1")

        @Override
        void execute(MultipleCandidatesDetails<String> details) {
            assert details.candidateValues == ["value1", "value2"] as Set
            details.closestMatch("value1")
        }
    }
    static class SelectionRuleWithParams implements AttributeDisambiguationRule<String> {
        String p1

        @Inject

        given:
        details.consumerValue >> "value1"
        details.producerValue >> "value2"
        ruleChain.add(BrokenRule)

        when:
        ruleChain.execute(details)

        then:
        def e = thrown(AttributeMatchException)
        e.message == 'Could not determine whether value value2 is compatible with value value1 using DefaultCompatibilityRuleChainTest.BrokenRule.'

    }

    @Test
    public void test_setAndGetAsArray() {
        String value1 = "a";
        String value2 = "b";
        String value3 = "c";
        settings.badword().add(value1);
        settings.badword().add(value2);
        settings.badword().add(value3);
        assertEquals(3, settings.badword().get(false).length);
        assertEquals(value1, settings.badword().get(false)[0]);

        baseManifest.attributes key1: 'value1', key2: 'value2'
        mergeSpec.from(new DefaultManifest(Mock(FileResolver)))
        mergeSpec.eachEntry {ManifestMergeDetails details ->
            if (details.getKey() == 'key2') {
                details.exclude()
            }
        }

        expect:
        mergeSpec.merge(baseManifest, Mock(FileResolver)).attributes == [key1: 'value1'] + MANIFEST_VERSION_MAP
    }

    def canIterateOverClassesUsingClosure() {
        TestDomainObject value1 = new TestDomainObject('a')
        TestDomainObject value2 = new TestDomainObject('a')
        repository.put('class1', value1)
        repository.put('class2', value2)
        Closure cl = Mock()

        when:
        repository.each(cl)

        then:
        1 * cl.call(['class1', value1] as Object[])
        1 * cl.call(['class2', value2] as Object[])

        String key = "key";
        String value1 = "a";
        String value2 = "b";
        String value3 = "c";
        settings.array().add(key, value1);
        settings.array().add(key, value2);
        settings.array().add(key, value3);
        assertEquals(3, settings.array().get(key).length);
        assertEquals(value1, settings.array().get(key)[0]);

        then:
        failureCauseContains("No tests found for given includes: [SubClass.$testMethod](--tests filter)")

        where:
        testMethod << ["sub unrolled test param=value1", "super unrolled test param=value1", "super super unrolled test param=value1"]
    }

    /**
     * 1番目の値を返します。
     *
     * @return 1番目の値
     */
    public T1 getValue1() {
        return value1;
    }

    /**
     * 1番目の値を設定します。
     *
     * @param value1
     *            1番目の値
     */
    public void setValue1(final T1 value1) {
        this.value1 = value1;
    }

    /**
     * 2番目の値を返します。
     *
     * @return 2番目の値
     */