def classFile = file("build/classes/java/main/Thing.class")
        classFile.isFile()
        def jarFile = file("build/libs/somelib.jar")
        new ZipTestFixture(jarFile).hasDescendants("META-INF/MANIFEST.MF", "Thing.class")

        when:

        throw IndexOutOfBoundsException("Index $index out of bounds")
    }

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

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        return emptyList()
    }

    override val classIds: Set<ClassId>
        get() = withValidityAssertion { emptySet() }

                classpath = files()
            }
            dependencies {
                implementation "org:foo:1.0"
                implementation "org:foo:1.0:classy"
            }

            publishing {
                repositories {
                    maven { url "${mavenRepo.uri}" }
                }
                publications {

    public val DOUBLE: ClassId = ClassId.topLevel(StandardNames.FqNames._double.toSafe())
    public val CHAR: ClassId = ClassId.topLevel(StandardNames.FqNames._char.toSafe())
    public val BOOLEAN: ClassId = ClassId.topLevel(StandardNames.FqNames._boolean.toSafe())
    public val STRING: ClassId = ClassId.topLevel(StandardNames.FqNames.string.toSafe())

        }
    }

    data class SamConstructorData(val classId: ClassId) : SymbolData() {
        override fun KaSession.toSymbols(ktFile: KtFile): List<KaSymbol> {
            val symbol = getClassOrObjectSymbolByClassId(classId)
                ?: getTypeAliasByClassId(classId)
                ?: error("Class-like symbol is not found by '$classId'")

    override fun getClassLikeDeclarationByClassId(classId: ClassId): KtClassLikeDeclaration? {
        return providers.firstNotNullOfOrNull { it.getClassLikeDeclarationByClassId(classId) }
    }

    override fun getAllClassesByClassId(classId: ClassId): Collection<KtClassOrObject> {
        return providers.flatMap { it.getAllClassesByClassId(classId) }
    }

    override fun getAllTypeAliasesByClassId(classId: ClassId): Collection<KtTypeAlias> {

		Name: "/cpu/classes/gc/mark/dedicated:cpu-seconds",
		Description: "Estimated total CPU time spent performing GC tasks on " +
			"processors (as defined by GOMAXPROCS) dedicated to those tasks. " +
			"This metric is an overestimate, and not directly comparable to " +
			"system CPU time measurements. Compare only with other /cpu/classes " +
			"metrics.",
		Kind:       KindFloat64,
		Cumulative: true,
	},
	{

    }

    @Override
    public boolean hasOutput(final long classId, final TestOutputEvent.Destination destination) {
        final boolean[] hasOutput = new boolean[1];
        withReader(new Action<TestOutputStore.Reader>() {
            @Override
            public void execute(TestOutputStore.Reader reader) {
                hasOutput[0] = reader.hasOutput(classId, destination);
            }
        });
        return hasOutput[0];

            annotationRenderer: KaAnnotationRenderer,
            printer: PrettyPrinter,
        ) {
            printer {
                val classId = annotation.classId
                if (classId != null) {
                    append(classId.asSingleFqName().render())
                } else {
                    append("ERROR_ANNOTATION")
                }
            }
        }
    }

    <property name="classes.dir" value="${build.dir}/classes"/>

    <target name="cleanAll">
        <delete dir="${build.dir}"/>
    </target>

    <target name="prepare">
        <tstamp>
            <format property="now" pattern="yyyy-MM-dd hh:mm:ss"/>
        </tstamp>
    </target>

    <target name="build" depends="prepare">
        <mkdir dir="${classes.dir}"/>