beforeExecute(executer -> {
            try {
                FileSystemWatchingHelper.waitForChangesToBePickedUp();
            } catch (InterruptedException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        });
    }

    @Override
    public GradleExecuter reset() {
        DeprecationLogger.reset();
        IncubationLogger.reset();

   * <ol>
   *   <li>All its mutation methods result in UnsupportedOperationException, and do not change the
   *       underlying contents.
   *   <li>All methods that return objects that can indirectly mutate the collection throw
   *       UnsupportedOperationException when those mutators are called.
   * </ol>
   *
   * @param collection the presumed-immutable collection

public class FailingBuildAction implements BuildAction<SomeToolingModel> {
    @Override
    public SomeToolingModel execute(BuildController controller) {
        controller.getBuildModel();
        throw new RuntimeException("Build action expectedly failed");
    }

   * <ol>
   *   <li>All its mutation methods result in UnsupportedOperationException, and do not change the
   *       underlying contents.
   *   <li>All methods that return objects that can indirectly mutate the collection throw
   *       UnsupportedOperationException when those mutators are called.
   * </ol>
   *
   * @param collection the presumed-immutable collection

    override fun iterator(): Iterator<KaAnnotation> = withValidityAssertion {
        return Collections.emptyIterator()
    }

    override fun get(index: Int): KaAnnotation = withValidityAssertion {
        throw IndexOutOfBoundsException("Index $index out of bounds")
    }

    override fun contains(classId: ClassId): Boolean = withValidityAssertion {
        return false
    }

    }

    def "background job is rejected if submitted after shutdown"() {
        given:
        jobExecutors.stop()

        when:
        jobExecutors.userJobExecutor.execute {}

        then:
        thrown RejectedExecutionException
    }

    def "isInBackground returns proper status from inside the job"() {
        when:
        def task = new FutureTask<>(jobExecutors::isInBackground)

sealed class IntermediateModel {
    abstract fun <T> result(): T?

    class NoModel(val message: String) : IntermediateModel() {
        override fun <T> result() = throw UnknownModelException(message)
    }

    object NullModel : IntermediateModel() {
        override fun <T> result(): T? = null
    }

    class Model(val value: Any) : IntermediateModel() {

                isStatic = firSymbol.isStatic,
            )

            KaSymbolKind.LOCAL -> throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(
                callableId?.toString() ?: name.asString()
            )

            else -> throw UnsupportedSymbolKind(this::class, kind)
        }
    }

    override fun equals(other: Any?): Boolean = symbolEquals(other)

			print("coro: got lock internal ", mp.lockedInt, ", want ", c.lockedInt, "\n")
			print("coro: got lock external ", mp.lockedExt, ", want ", c.lockedExt, "\n")
			throw("coro: OS thread locking must match locking at coroutine creation")
		}
	}

	// Acquire tracer for writing for the duration of this call.
	//
	// There's a lot of state manipulation performed with shortcuts

    override fun createPointer(): KaSymbolPointer<KaAnonymousObjectSymbol> = withValidityAssertion {
        KaPsiBasedSymbolPointer.createForSymbolFromSource<KaAnonymousObjectSymbol>(this)?.let { return it }

        throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(this::class)
    }

    override fun equals(other: Any?): Boolean = symbolEquals(other)
    override fun hashCode(): Int = symbolHashCode()