return getIdeWorspace();
    }

    @Override
    public Artifact find(Artifact artifact) {
        if (!artifact.isRelease() && buildReactor != null) {
            artifact = buildReactor.find(artifact);
        }

        if (!artifact.isResolved() && ideWorkspace != null) {
            artifact = ideWorkspace.find(artifact);
        }

        if (!artifact.isResolved()) {

            throw new FessSystemException("Could not find extractorFactory.");
        }
        Extractor extractor = extractorFactory.getExtractor(responseData.getMimeType());
        if (extractor == null) {
            extractor = ComponentUtil.getComponent("tikaExtractor");
            if (extractor == null) {
                throw new FessSystemException("Could not find tikaExtractor.");
            }
        }

            ?: error("Can't find containing declaration for $declarationAtCaret")

        val containingClass = getContainingKtLightClass(containingDeclaration, mainFile)
        val psiContext = containingClass.findLightDeclarationContext(containingDeclaration)
            ?: error("Can't find psi context for $containingDeclaration")

        val actual = analyze(mainFile) {

                is KtParameter -> psi.destructuringDeclaration
                    ?: errorWithAttachment("Expected to find lambda ${KtParameter::class} with ${KtDestructuringDeclaration::class}") {
                        withPsiEntry("psi", psi)
                    }
                else -> errorWithAttachment("Expected to find ${KtDestructuringDeclaration::class} or ${KtParameter::class} but ${psi?.let { it::class }} found") {

                ?: error("Cannot find enum class `${enumEntryId.classId}`.")

            require(classSymbol is KaNamedClassOrObjectSymbol) { "`${enumEntryId.classId}` must be a named class." }
            require(classSymbol.classKind == KaClassKind.ENUM_CLASS) { "`${enumEntryId.classId}` must be an enum class." }

            val enumEntrySymbol = classSymbol.getEnumEntries().find { it.name == enumEntryId.callableName }

            throw KotlinExceptionWithAttachments("Cannot find a KtModule for a non-physical file")
                .withPsiAttachment("containingFile", containingFile)
                .withAttachment("contextualModule", contextualModule?.asDebugString())
        }

        return allKtModules.firstOrNull { module -> virtualFile in module.contentScope }
            ?: throw KotlinExceptionWithAttachments("Cannot find a KtModule for the VirtualFile")

    public UnknownRepositoryLayoutException(String repositoryId, String layoutId) {
        super("Cannot find ArtifactRepositoryLayout instance for: " + layoutId, repositoryId);
        this.layoutId = layoutId;
    }

    public UnknownRepositoryLayoutException(String repositoryId, String layoutId, ComponentLookupException e) {
        super("Cannot find ArtifactRepositoryLayout instance for: " + layoutId, repositoryId, e);
        this.layoutId = layoutId;

tail -f ./fess-*/logs/*.log &

mvn test -P integrationTests -Dtest.fess.url="http://localhost:8080" -Dtest.search_engine.url="http://localhost:9201"
ret=$?

if [ $ret != 0 ] ; then
  for f in `find ./target -type f | grep surefire-reports | grep -v /TEST-` ; do
    cat $f
  done
fi

        val symbolByJavaPsi = when (val javaPsi = symbolByReference.psi) {
            is PsiClass -> javaPsi.getNamedClassSymbol()
            is PsiMember -> javaPsi.getCallableSymbol()
            null -> error("Failed to find psi for symbol")
            else -> unexpectedElementError<PsiElement>(javaPsi)
        }

        return SymbolsData(listOfNotNull(symbolByJavaPsi))
    }

import org.jetbrains.kotlin.psi.psiUtil.findDescendantOfType
import org.jetbrains.kotlin.test.services.TestServices
import org.jetbrains.kotlin.test.services.assertions

/**
 * To find the element for the use-site position, the visibility checker test looks for an element called "useSite" in the main module if