* @param generatedMethodDetector Predicate to test if a method was generated (vs. being provided explicitly by the user).
     * @param mutableNonFinalClasses Mutable classes that shouldn't need explicit setters
     * @param cacheFactory A factory to create cross-build in-memory caches.
     */
    public DefaultTypeAnnotationMetadataStore(
        Collection<Class<? extends Annotation>> recordedTypeAnnotations,

            is ConeLookupTagBasedType -> lookupTag.name.asString()

            // NOTE: Flexible types can occur not only as implicit return types,
            // but also as implicit parameter types, for example in setters with implicit types
            is ConeFlexibleType -> {
                // since Kotlin decompiler always "renders" flexible types as their lower bound, we can do the same here
                lowerBound.renderTypeAsKotlinType()

    /**
     * Fetches a snapshot of the model of the given type for the given element using the given parameter.
     *
     * <p>The parameter type must be an interface only with getters and setters and no nesting is supported.
     * The Tooling API will create a proxy instance of this interface and use the initializer to run against
     * that instance to configure it and then pass to the model builder.
     * </p>

        suggester.refresh();

        final SuggestResponse response = suggester.suggest().setQuery("検索").setSuggestDetail(true).execute().getResponse();
        final List<SuggestItem> items = response.getItems();
        assertEquals(1, response.getNum());
        assertEquals("検索 エンジン", items.get(0).getText());
    }

    @Test
    public void test_indexFromSearchWordExclude() throws Exception {

    //TODO Check thread safety
    session.jvmTypeMapper.mapType(this, mode, signatureWriter) {
        val containingFile = useSitePosition.containingKtFile
        // parameters for default setters does not have kotlin origin, but setter has
            ?: (useSitePosition as? KtLightParameter)?.parent?.parent?.containingKtFile
            ?: return@mapType null

            buf.append(",\"page_size\":").append(suggestResponse.getNum());

            if (!suggestResponse.getItems().isEmpty()) {
                buf.append(",\"data\":[");

                boolean first = true;
                for (final SuggestItem item : suggestResponse.getItems()) {
                    if (!first) {
                        buf.append(',');
                    }

    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 {

            builderCall.callback(bulkBuilder);
        }

        final BulkResponse response = bulkBuilder.execute().actionGet(bulkTimeout);
        final BulkItemResponse[] itemResponses = response.getItems();
        if (itemResponses.length != entityList.size()) {
            throw new IllegalStateException("Invalid response size: " + itemResponses.length + " != " + entityList.size());
        }

					v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI),
				},
			}
			// Since this test retroactively overrides the stub container manager,
			// we have to regenerate default status setters.
			kubelet.setNodeStatusFuncs = kubelet.defaultNodeStatusFuncs()

			kubeClient := testKubelet.fakeKubeClient
			existingNode := v1.Node{ObjectMeta: metav1.ObjectMeta{Name: testKubeletHostname}}

            builderCall.callback(bulkBuilder);
        }

        final BulkResponse response = bulkBuilder.execute().actionGet(bulkTimeout);
        final BulkItemResponse[] itemResponses = response.getItems();
        if (itemResponses.length != entityList.size()) {
            throw new IllegalStateException("Invalid response size: " + itemResponses.length + " != " + entityList.size());
        }