final Set<Class<?>> categories = new HashSet<Class<?>>();
        Category annotation = description.getAnnotation(Category.class);
        if (annotation != null) {
            categories.addAll(Arrays.asList(annotation.value()));
        }

        if (parent != null) {
            annotation = parent.getAnnotation(Category.class);
            if (annotation != null) {

// LANGUAGE: +ContextReceivers

// MODULE: context

// FILE: context.kt
class Ctx1
class Ctx2
class Ctx3
class Ctx4

context(Ctx1, Ctx2, Ctx3, Ctx4)
fun useWithCtx1Ctx2Ctx3Ctx4() = 3

context(Ctx1, Ctx2)
class Test {
    context(Ctx3, Ctx4)
    fun foo() {
        <caret_context>val x = 1
    }
}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt

                testImplementation("junit:junit:4.13")
            }
        """
        file("src/main/groovy/Thing.groovy") << """
            class Thing {}
        """
        file("src/test/groovy/ThingTest.groovy") << """
            import org.junit.*
            class ThingTest {
                @Test void ok() { new Thing() }
            }
        """

        and:
        def expectedTasks = [

  }

  @SuppressWarnings("rawtypes") // class literals
  @Override
  protected List<Class<? extends AbstractTester>> getTesters() {
    List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
    testers.add(SetMultimapAsMapTester.class);
    testers.add(SetMultimapEqualsTester.class);
    testers.add(SetMultimapPutTester.class);
    testers.add(SetMultimapPutAllTester.class);

  static class CustomRuntimeException extends RuntimeException {}

  public void testCatching() throws Exception {
    FluentFuture<?> f =
        FluentFuture.from(immediateFailedFuture(new CustomRuntimeException()))
            .catching(
                Throwable.class,
                new Function<Throwable, Class<?>>() {
                  @Override

public final class MainKt {
    // source: 'main.kt'
    inner (anonymous) class MainKt$ArticleScreenContent$1
    inner (anonymous) class MainKt$ArticleScreenContent$2
    synthetic static method ArticleScreenContent$default(p0: java.lang.String, p1: kotlin.jvm.functions.Function0, p2: int, p3: java.lang.Object): void
    private final static method ArticleScreenContent(p0: java.lang.String, p1: kotlin.jvm.functions.Function0): void

        }
    }

    private static class CompositeBuildTreeScopeServices implements ServiceRegistrationProvider {
        public void configure(ServiceRegistration serviceRegistration) {
            serviceRegistration.add(BuildStateFactory.class);
            serviceRegistration.add(DefaultIncludedBuildFactory.class);
            serviceRegistration.add(DefaultIncludedBuildTaskGraph.class);

        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final ConstructorDesc ctor = beanDesc.getConstructorDesc(String.class);
        assertThat(ctor, is(notNullValue()));
        assertThat(ctor.getBeanDesc(), is(sameInstance(beanDesc)));
        assertThat(ctor.getConstructor(), is((Constructor) MyBean.class.getConstructor(String.class)));
        assertThat(ctor.getParameterTypes().length, is(1));

        sealed interface StageFailure {
            data class NoSchemaAvailable(val scriptContext: DeclarativeScriptContext) : StageFailure
            object NoParseResult : StageFailure
            data class FailuresInLanguageTree(val failures: List<SingleFailureResult>) : StageFailure
            data class FailuresInResolution(val errors: List<ResolutionError>) : StageFailure

import org.codelibs.core.lang.FieldUtil;
import org.codelibs.core.lang.MethodUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class StandardCrawlerContainer implements CrawlerContainer {

    private final Logger logger = LoggerFactory.getLogger(StandardCrawlerContainer.class);

    private final Map<String, ComponentHolder<?>> singletonMap = new ConcurrentHashMap<>();