outputs.file(originalJar);
        } else if (moduleInfo.containsKey(originalJarName)) {
            addModuleDescriptor(originalJar, getModuleJar(outputs, originalJar), moduleInfo.get(originalJarName));
        } else if (isAutoModule(originalJar)) {
            outputs.file(originalJar);
        } else if (automaticModules.containsKey(originalJarName)) {

        m2Compatible ? organisation.replaceAll(/\./, '/') : organisation
    }

    static String substitute(String pattern, boolean m2Compatible, Map<String, String> tokens) {
        if (tokens.containsKey('organisation')) {
            tokens.put('organisation', organisationToken(m2Compatible, tokens.get('organisation')))
        }
        IvyPatternHelper.substituteTokens(pattern, tokens)
    }

        final CrawlerStatsHelper crawlerStatsHelper = ComponentUtil.getCrawlerStatsHelper();
        synchronized (indexUpdateCallback) {
            // required check
            if (!dataMap.containsKey(fessConfig.getIndexFieldUrl()) || dataMap.get(fessConfig.getIndexFieldUrl()) == null) {
                logger.warn("Could not add a doc. Invalid data: {}", dataMap);
                return;
            }

    public Actor createActor(Object target) {
        if (target instanceof NonBlockingActor) {
            return (NonBlockingActor) target;
        }
        synchronized (lock) {
            if (blockingActors.containsKey(target)) {
                throw new UnsupportedOperationException("Cannot create a non-blocking and blocking actor for the same object. This is not implemented yet.");
            }

        assertHasTypeForExtension(defaultTypeExtension);
        this.defaultTypeExtension = defaultTypeExtension;
    }

    @Override
    public boolean hasTypeForExtension(String extension) {
        return types.containsKey(extension);
    }

    @Override
    public SignatureType getTypeForExtension(String extension) {
        assertHasTypeForExtension(extension);
        return types.get(extension);
    }

 *
 * @author higa
 */
public class BeanMap extends LinkedHashMap<String, Object> {

    private static final long serialVersionUID = 1;

    @Override
    public Object get(final Object key) {
        if (!containsKey(key)) {
            throw new IllegalKeyOfBeanMapException(key, this);
        }
        return super.get(key);
    }

        // We can't "unset" the variable with the API executer provides, but it isn't necessary, thanks to the filtering in
        // build-logic/jvm/src/main/kotlin/gradlebuild/propagated-env-variables.kt
        if (System.getenv().containsKey(key)) {
            throw new IllegalStateException("Environment variable $key is present for this process and may affect tests")
        }
    }

    val testPathToBinaryResultsDirs: Map<String, File>
        get() = parameters.testPathToBinaryResultsDirs.get()

    override fun onFinish(event: FinishEvent) {
        if (event is TaskFinishEvent && taskPathReports.containsKey(event.descriptor.taskPath)) {
            val taskPath = event.descriptor.taskPath
            when (event.result) {
                is TaskSuccessResult -> {
                    addExecutedTaskPath(taskPath)

            tokensFor = LinkedHashMultimap.create();
        }
        tokensFor.put(expression, tokens);
    }

    boolean hasTokensFor(Expression expression) {
        return tokensFor != null && tokensFor.containsKey(expression);
    }

    }

    static EnvVariableRead getEnvContainsKey(String name) {
        return new EnvVariableRead() {
            @Override
            String getKotlinExpression() {
                return "System.getenv().containsKey(\"$name\")"
            }
        }
    }