final String value = clientConfigMap.get(CRAWLER_CLIENTS);
        final CrawlerClient client = getClientRuleList(value).stream().map(e -> {
            if (e.getSecond().matcher(url).matches()) {
                return e.getFirst();
            }
            return null;
        }).filter(StringUtil::isNotBlank).findFirst()//
                .map(s -> clientFactory.getClient(s + ":" + url))//

* Many other types extend `Provider` and can be used wherever a `Provider` is required.

[[managed_properties]]
== Using Gradle Managed Properties

Gradle's managed properties allow you to declare properties as abstract getters (Java, Groovy) or abstract properties (Kotlin).

Gradle then automatically provides the implementation for these properties, managing their state.

  //  3. block_size of for the space to depth transform for these convolutions
  //     are larger than 1.
  for (auto argnum_and_convolution : argnum_and_convolutions) {
    auto arg_num = argnum_and_convolution.getFirst();
    auto conv2d_and_block_sizes = argnum_and_convolution.getSecond();
    // Continue if number of users of the block argment doesn't equal to number
    // of transformable convolutions and there is no qualified convolution

            }
        """

        when:
        succeeds 'taskWithInputs'

        then:
        skipped(':taskWithInputs')
    }

    @ToBeImplemented("Private getters should be ignored")
    def "private inputs can be overridden in subclass"() {
        given:
        buildFile << '''
            abstract class MyBaseTask extends DefaultTask {

                @Inject

            final List<String> roles = new ArrayList<>();

            for (final Pair<String, String> searchFieldLog : searchLog.getSearchFieldLogList()) {
                final String name = searchFieldLog.getFirst();
                if (contentFieldNameSet.contains(name)) {
                    if (sb.length() > 0) {
                        sb.append(TEXT_SEP);
                    }

        final Pair<String, String>[] designJspFileNames = systemHelper.getDesignJspFileNames();
        assertEquals(1, designJspFileNames.length);
        assertEquals("xxx", designJspFileNames[0].getFirst());
        assertEquals("yyy", designJspFileNames[0].getSecond());
    }

    public void test_setForceStop() {
        assertFalse(systemHelper.isForceStop());
        systemHelper.setForceStop(true);

        });
        selectorState.update(dependencyState);
        return selectorState;
    }

    @Nullable
    public NodeState peek() {
        return queue.isEmpty() ? null : queue.getFirst();
    }

    public NodeState pop() {
        NodeState next = queue.removeFirst();
        return next.dequeue();
    }

    /**

        private static final int PUBLIC_STATIC_FINAL = Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL;
        private String className;
        /**
         * We only add getters for `public static final String` constants. This is because in
         * the converted classes only contain these kinds of constants.
         *

    // with `bias` from the BiasAddOp appended.
    SmallVector<Value, 4> operands(contraction.operand_begin(),
                                   contraction.operand_end());
    operands.push_back(bias_add.getBias());

    // The fused contraction has the same attributes as the original
    // contraction, with two additions: the list of ops which have been fused
    // together; epsilon (only with FusedBatchNorm).

    return callee !is KtReferenceExpression ||
            analyze(callee) {
                isSimpleVariableAccessCall(callee)
            }
}

/**
 * The body of setters are always used. The body of getters are only used if they are expression bodies.
 */
private fun doesPropertyAccessorUseBody(propertyAccessor: KtPropertyAccessor, body: PsiElement): Boolean {