private final ValueProducer left;
        private final ValueProducer right;

        public PlusProducer(ValueProducer left, ValueProducer right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public boolean isKnown() {
            return left.isKnown() || right.isKnown();
        }

        @Override

        buffer.consumeWhitespace();
        while (buffer.consume("##")) {
            buffer.consumeWhitespace();
            right = buffer.readIdentifier();
            if (right == null) {
                // Need another identifier
                buffer.pos = pos;

    @Override
    public Pair<RelativePath, ClassVisitor> apply(ClasspathEntryVisitor.Entry entry, ClassVisitor visitor, ClassData classData) throws IOException {
        return first.apply(entry, second.apply(entry, visitor, classData).right, classData);
    }

        return credentialsProviderFactory.provide(credentialsType, identity);
    }

    @Override
    public <A, B, R> Provider<R> zip(Provider<A> left, Provider<B> right, BiFunction<? super A, ? super B, ? extends R> combiner) {
        return left.zip(right, combiner);
    }

        val hasher = Hashing.newHasher()
        // This routine is used to snapshot results of File.list(), File.listFiles() and similar calls.
        // Technically, the relative order or entries is visible to the caller, so it might be considered when computing the hash.
        // However, the File.list spec leaves the order undefined, so no reasonable implementation should depend on it.

    def buildFinishedHandler = Mock(IntermediateResultHandler)
    def listener = new DefaultPhasedActionResultListener(projectsLoadedHandler, buildFinishedHandler)

    def "right handler is called"() {
        when:
        listener.onResult(new ProjectsLoadedResult<String>('result1'))
        listener.onResult(new BuildFinishedResult<String>('result2'))

        then:

        warn(
            """
                WARNING: Unsupported Kotlin plugin version.
                The `embedded-kotlin` and `kotlin-dsl` plugins rely on features of Kotlin `{}` that might work differently than in the requested version `{}`.
            """.trimIndent(),
            embeddedKotlinVersion,
            kotlinVersion
        )
    }
}


internal

            attach(unassignedProgressOperations.pop());
        }
    }

    // Declares that we are stopping showing updates from this ProgressOperation.
    // We might be completely done following this ProgressOperation, or
    // we might simply be waiting for its children to complete.
    private void unshow(ProgressOperation operation) {
        OperationIdentifier operationId = operation.getOperationId();

            Class.forName(superclass.name, true, superclass.classLoader)
            maybeInit(superclass)
        }
    }

    // TODO: What about the runtime decorations a serialized bean might have had at configuration time?
    private
    fun newConstructorForSerialization(beanType: Class<*>, constructor: Constructor<*>): Constructor<out Any> =

        return cacheBuilderFactory.getRootDir();
    }

    /**
     * Is the build using an empty settings because a build definition is missing from the current directory?
     *
     * <p>There are two cases where this might be true: Gradle was invoked from a directory where there is no build script and no settings script in the directory hierarchy,