zipped instanceof Provider
        zipped.get() == 126
    }

    def "zip tracks task dependencies"() {
        def task1 = Stub(Task)
        def a = withProducer(Integer, task1, 5)
        def task2 = Stub(Task)
        def b = withProducer(String, task2, "Hello")

        when:
        def zipped = providerFactory.zip(a, b) { i, s -> s.length() == i } as ProviderInternal<Boolean>

        then:

    /**
     * Returns a matcher that uses the consumer rules from this schema, and the producer rules from the given schema.
     */
    AttributeMatcher withProducer(AttributesSchemaInternal producerSchema);

    /**
     * Returns a matcher that uses the rules from this schema, and assumes the producer has the same rules.
     */
    AttributeMatcher matcher();

    }

    @Override
    public AttributeMatcher matcher() {
        throw new UnsupportedOperationException();
    }

    @Override
    public AttributeMatcher withProducer(AttributesSchemaInternal producerSchema) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> AttributeMatchingStrategy<T> attribute(Attribute<T> attribute) {

        assert values.length > 0;
        return new TestProviderWithChangingValue<>(Cast.uncheckedNonnullCast(cls), Arrays.asList(values), null);
    }

    public static <T> ProviderInternal<T> withProducer(Class<T> type, Task producer, T... values) {
        Class<T> valueType = values.length == 0 ? type : Cast.uncheckedNonnullCast(values[0].getClass());
        return new TestProvider<>(valueType, Arrays.asList(values), producer);

    def dependenciesResolverFactory = Mock(TransformUpstreamDependenciesResolverFactory)
    def attributeMatcher = Mock(AttributeMatcher)
    def attributesSchema = Mock(AttributesSchemaInternal) {
        withProducer(_) >> attributeMatcher
        getConsumerDescribers() >> []
        getFailureDescribers(_) >> []
    }
    def attributesFactory = AttributeTestUtil.attributesFactory()