package org.gradle.test.sub;

public class SubClass {

        """
    }

    def "can filter tests"() {
        when:
        succeeds("test", "--tests", "SubClass.$testMethod")

        then:
        new DefaultTestExecutionResult(testDirectory)
            .assertTestClassesExecuted("SubClass")
            .testClass("SubClass")
            .assertTestCount(1, 0, 0)
            .assertTestPassed(testMethod)

        where:

                subclass(ConfigureAccessorInternal.DefaultConfiguringLambdaArgument::class)
                subclass(ConfigureAccessorInternal.DefaultCustom::class)
                subclass(ConfigureAccessorInternal.DefaultProperty::class)
            }
            polymorphic(DataType::class) {
                subclass(DataTypeInternal.DefaultIntDataType::class)
                subclass(DataTypeInternal.DefaultLongDataType::class)

     *
     * @param subClass the subClass or object symbol.
     * @param superClass the super class symbol.
     * @return [KaSubstitutor] if [subClass] inherits [superClass] and there are no error types in the inheritance path. Returns `null` otherwise.
     */
    public fun createInheritanceTypeSubstitutor(
        subClass: KaClassOrObjectSymbol,
        superClass: KaClassOrObjectSymbol,

import com.google.common.collect.Lists;
import com.google.common.eventbus.Subscribe;
import com.google.common.eventbus.outside.AnnotatedNotAbstractInSuperclassTest.SubClass;
import java.util.List;

public class AnnotatedNotAbstractInSuperclassTest extends AbstractEventBusTest<SubClass> {
  static class SuperClass {
    final List<Object> notOverriddenInSubclassEvents = Lists.newArrayList();

/**
 * Returns whether [subClass] is a strict subtype of [superClass]. Resolves [subClass] to [FirResolvePhase.SUPER_TYPES].
 */
fun isSubClassOf(subClass: FirClass, superClass: FirClass, useSiteSession: FirSession, allowIndirectSubtyping: Boolean = true): Boolean {
    subClass.lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)

import com.google.common.collect.Lists;
import com.google.common.eventbus.Subscribe;
import com.google.common.eventbus.outside.NeitherAbstractNorAnnotatedInSuperclassTest.SubClass;
import java.util.List;

public class NeitherAbstractNorAnnotatedInSuperclassTest extends AbstractEventBusTest<SubClass> {
  static class SuperClass {
    final List<Object> neitherOverriddenNorAnnotatedEvents = Lists.newArrayList();

                }
            }
        """
        file('src/test/java/SubClass.java') << """
            ${testFrameworkImports}

            public class SubClass extends SuperClass {
                @Test
                public void subTest() {
                }
            }
        """

        when:
        succeeds('test', '--tests', 'SubClass.superTest')

        then:

        require(subClass is KaFirSymbol<*>)
        require(superClass is KaFirSymbol<*>)

        if (subClass == superClass) return false
        return isSubClassOf(
            subClass = subClass.firSymbol.fir as FirClass,
            superClass = superClass.firSymbol.fir as FirClass,
            rootModuleSession,

        }

        return overriddenDescriptors
    }

    override fun isSubClassOf(subClass: KaClassOrObjectSymbol, superClass: KaClassOrObjectSymbol): Boolean {
        if (subClass == superClass) return false

        val subClassDescriptor = getSymbolDescriptor(subClass) as? ClassDescriptor ?: return false
        val superClassDescriptor = getSymbolDescriptor(superClass) as? ClassDescriptor ?: return false